Subversion Repositories SmartDukaan

Rev

Rev 5031 | Rev 5099 | 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 
 
5031 varun.gupt 1107 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1108 
    """
1109 
    Parameters:
1110 
     - startDate
1111 
     - endDate
1112 
    """
1113 
    pass
4875 varun.gupt 1114 
 
5067 varun.gupt 1115 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1116 
    """
1117 
    Parameters:
1118 
     - status
1119 
     - startDatetime
1120 
     - endDatetime
1121 
    """
1122 
    pass
5031 varun.gupt 1123 
 
5067 varun.gupt 1124 
 
3376 rajveer 1125 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1126 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1127 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1128 
 
1129 
  def createTransaction(self, transaction):
1130 
    """
1131 
    Parameters:
1132 
     - transaction
1133 
    """
1134 
    self.send_createTransaction(transaction)
132 ashish 1135 
    return self.recv_createTransaction()
94 ashish 1136 
 
1137 
  def send_createTransaction(self, transaction):
1138 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1139 
    args = createTransaction_args()
1140 
    args.transaction = transaction
1141 
    args.write(self._oprot)
1142 
    self._oprot.writeMessageEnd()
1143 
    self._oprot.trans.flush()
1144 
 
1145 
  def recv_createTransaction(self, ):
1146 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1147 
    if mtype == TMessageType.EXCEPTION:
1148 
      x = TApplicationException()
1149 
      x.read(self._iprot)
1150 
      self._iprot.readMessageEnd()
1151 
      raise x
1152 
    result = createTransaction_result()
1153 
    result.read(self._iprot)
1154 
    self._iprot.readMessageEnd()
3431 rajveer 1155 
    if result.success is not None:
132 ashish 1156 
      return result.success
3431 rajveer 1157 
    if result.ex is not None:
94 ashish 1158 
      raise result.ex
132 ashish 1159 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1160 
 
1161 
  def getTransaction(self, id):
1162 
    """
1163 
    Parameters:
1164 
     - id
1165 
    """
1166 
    self.send_getTransaction(id)
1167 
    return self.recv_getTransaction()
1168 
 
1169 
  def send_getTransaction(self, id):
1170 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1171 
    args = getTransaction_args()
1172 
    args.id = id
1173 
    args.write(self._oprot)
1174 
    self._oprot.writeMessageEnd()
1175 
    self._oprot.trans.flush()
1176 
 
1177 
  def recv_getTransaction(self, ):
1178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1179 
    if mtype == TMessageType.EXCEPTION:
1180 
      x = TApplicationException()
1181 
      x.read(self._iprot)
1182 
      self._iprot.readMessageEnd()
1183 
      raise x
1184 
    result = getTransaction_result()
1185 
    result.read(self._iprot)
1186 
    self._iprot.readMessageEnd()
3431 rajveer 1187 
    if result.success is not None:
94 ashish 1188 
      return result.success
3431 rajveer 1189 
    if result.ex is not None:
94 ashish 1190 
      raise result.ex
1191 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1192 
 
1193 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1194 
    """
1195 
    Parameters:
1196 
     - customerId
1197 
     - from_date
1198 
     - to_date
1199 
     - status
1200 
    """
1201 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1202 
    return self.recv_getTransactionsForCustomer()
1203 
 
1204 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1205 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1206 
    args = getTransactionsForCustomer_args()
1207 
    args.customerId = customerId
1208 
    args.from_date = from_date
1209 
    args.to_date = to_date
1210 
    args.status = status
1211 
    args.write(self._oprot)
1212 
    self._oprot.writeMessageEnd()
1213 
    self._oprot.trans.flush()
1214 
 
1215 
  def recv_getTransactionsForCustomer(self, ):
1216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1217 
    if mtype == TMessageType.EXCEPTION:
1218 
      x = TApplicationException()
1219 
      x.read(self._iprot)
1220 
      self._iprot.readMessageEnd()
1221 
      raise x
1222 
    result = getTransactionsForCustomer_result()
1223 
    result.read(self._iprot)
1224 
    self._iprot.readMessageEnd()
3431 rajveer 1225 
    if result.success is not None:
94 ashish 1226 
      return result.success
3431 rajveer 1227 
    if result.ex is not None:
94 ashish 1228 
      raise result.ex
1229 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1230 
 
132 ashish 1231 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1232 
    """
1233 
    Parameters:
1234 
     - shoppingCartId
1235 
    """
1236 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1237 
    return self.recv_getTransactionsForShoppingCartId()
1238 
 
1239 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1240 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1241 
    args = getTransactionsForShoppingCartId_args()
1242 
    args.shoppingCartId = shoppingCartId
1243 
    args.write(self._oprot)
1244 
    self._oprot.writeMessageEnd()
1245 
    self._oprot.trans.flush()
1246 
 
1247 
  def recv_getTransactionsForShoppingCartId(self, ):
1248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1249 
    if mtype == TMessageType.EXCEPTION:
1250 
      x = TApplicationException()
1251 
      x.read(self._iprot)
1252 
      self._iprot.readMessageEnd()
1253 
      raise x
1254 
    result = getTransactionsForShoppingCartId_result()
1255 
    result.read(self._iprot)
1256 
    self._iprot.readMessageEnd()
3431 rajveer 1257 
    if result.success is not None:
132 ashish 1258 
      return result.success
3431 rajveer 1259 
    if result.ex is not None:
132 ashish 1260 
      raise result.ex
1261 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1262 
 
94 ashish 1263 
  def getTransactionStatus(self, transactionId):
1264 
    """
1265 
    Parameters:
1266 
     - transactionId
1267 
    """
1268 
    self.send_getTransactionStatus(transactionId)
1269 
    return self.recv_getTransactionStatus()
1270 
 
1271 
  def send_getTransactionStatus(self, transactionId):
1272 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1273 
    args = getTransactionStatus_args()
1274 
    args.transactionId = transactionId
1275 
    args.write(self._oprot)
1276 
    self._oprot.writeMessageEnd()
1277 
    self._oprot.trans.flush()
1278 
 
1279 
  def recv_getTransactionStatus(self, ):
1280 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1281 
    if mtype == TMessageType.EXCEPTION:
1282 
      x = TApplicationException()
1283 
      x.read(self._iprot)
1284 
      self._iprot.readMessageEnd()
1285 
      raise x
1286 
    result = getTransactionStatus_result()
1287 
    result.read(self._iprot)
1288 
    self._iprot.readMessageEnd()
3431 rajveer 1289 
    if result.success is not None:
94 ashish 1290 
      return result.success
3431 rajveer 1291 
    if result.ex is not None:
94 ashish 1292 
      raise result.ex
1293 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1294 
 
1295 
  def changeTransactionStatus(self, transactionId, status, description):
1296 
    """
1297 
    Parameters:
1298 
     - transactionId
1299 
     - status
1300 
     - description
1301 
    """
1302 
    self.send_changeTransactionStatus(transactionId, status, description)
1303 
    return self.recv_changeTransactionStatus()
1304 
 
1305 
  def send_changeTransactionStatus(self, transactionId, status, description):
1306 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1307 
    args = changeTransactionStatus_args()
1308 
    args.transactionId = transactionId
1309 
    args.status = status
1310 
    args.description = description
1311 
    args.write(self._oprot)
1312 
    self._oprot.writeMessageEnd()
1313 
    self._oprot.trans.flush()
1314 
 
1315 
  def recv_changeTransactionStatus(self, ):
1316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1317 
    if mtype == TMessageType.EXCEPTION:
1318 
      x = TApplicationException()
1319 
      x.read(self._iprot)
1320 
      self._iprot.readMessageEnd()
1321 
      raise x
1322 
    result = changeTransactionStatus_result()
1323 
    result.read(self._iprot)
1324 
    self._iprot.readMessageEnd()
3431 rajveer 1325 
    if result.success is not None:
94 ashish 1326 
      return result.success
3431 rajveer 1327 
    if result.ex is not None:
94 ashish 1328 
      raise result.ex
1329 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1330 
 
1398 varun.gupt 1331 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1332 
    """
1333 
    Parameters:
1334 
     - transactionId
1335 
    """
1398 varun.gupt 1336 
    self.send_enqueueTransactionInfoEmail(transactionId)
1337 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1338 
 
1398 varun.gupt 1339 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1340 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1341 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1342 
    args.transactionId = transactionId
1343 
    args.write(self._oprot)
1344 
    self._oprot.writeMessageEnd()
1345 
    self._oprot.trans.flush()
1346 
 
1398 varun.gupt 1347 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1348 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1349 
    if mtype == TMessageType.EXCEPTION:
1350 
      x = TApplicationException()
1351 
      x.read(self._iprot)
1352 
      self._iprot.readMessageEnd()
1353 
      raise x
1398 varun.gupt 1354 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1355 
    result.read(self._iprot)
1356 
    self._iprot.readMessageEnd()
3431 rajveer 1357 
    if result.success is not None:
1382 varun.gupt 1358 
      return result.success
3431 rajveer 1359 
    if result.ex is not None:
1382 varun.gupt 1360 
      raise result.ex
1398 varun.gupt 1361 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1362 
 
4801 anupam.sin 1363 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1364 
    """
1365 
    Parameters:
4801 anupam.sin 1366 
     - statuses
483 rajveer 1367 
     - from_date
1368 
     - to_date
1369 
     - warehouse_id
94 ashish 1370 
    """
4801 anupam.sin 1371 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1372 
    return self.recv_getAllOrders()
94 ashish 1373 
 
4801 anupam.sin 1374 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1375 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1376 
    args = getAllOrders_args()
4801 anupam.sin 1377 
    args.statuses = statuses
483 rajveer 1378 
    args.from_date = from_date
1379 
    args.to_date = to_date
1380 
    args.warehouse_id = warehouse_id
94 ashish 1381 
    args.write(self._oprot)
1382 
    self._oprot.writeMessageEnd()
1383 
    self._oprot.trans.flush()
1384 
 
483 rajveer 1385 
  def recv_getAllOrders(self, ):
94 ashish 1386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1387 
    if mtype == TMessageType.EXCEPTION:
1388 
      x = TApplicationException()
1389 
      x.read(self._iprot)
1390 
      self._iprot.readMessageEnd()
1391 
      raise x
483 rajveer 1392 
    result = getAllOrders_result()
94 ashish 1393 
    result.read(self._iprot)
1394 
    self._iprot.readMessageEnd()
3431 rajveer 1395 
    if result.success is not None:
94 ashish 1396 
      return result.success
3431 rajveer 1397 
    if result.ex is not None:
94 ashish 1398 
      raise result.ex
483 rajveer 1399 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1400 
 
4133 chandransh 1401 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1402 
    """
1403 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1404 
    Pass the status as null and the limit as 0 to ignore them.
1405 
 
1406 
    Parameters:
1407 
     - statuses
1408 
     - offset
1409 
     - limit
1410 
     - warehouse_id
1411 
    """
1412 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1413 
    return self.recv_getOrdersInBatch()
1414 
 
1415 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1416 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1417 
    args = getOrdersInBatch_args()
1418 
    args.statuses = statuses
1419 
    args.offset = offset
1420 
    args.limit = limit
1421 
    args.warehouse_id = warehouse_id
1422 
    args.write(self._oprot)
1423 
    self._oprot.writeMessageEnd()
1424 
    self._oprot.trans.flush()
1425 
 
1426 
  def recv_getOrdersInBatch(self, ):
1427 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1428 
    if mtype == TMessageType.EXCEPTION:
1429 
      x = TApplicationException()
1430 
      x.read(self._iprot)
1431 
      self._iprot.readMessageEnd()
1432 
      raise x
1433 
    result = getOrdersInBatch_result()
1434 
    result.read(self._iprot)
1435 
    self._iprot.readMessageEnd()
1436 
    if result.success is not None:
1437 
      return result.success
1438 
    if result.ex is not None:
1439 
      raise result.ex
1440 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1441 
 
1442 
  def getOrderCount(self, statuses, warehouseId):
1443 
    """
1444 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1445 
 
1446 
    Parameters:
1447 
     - statuses
1448 
     - warehouseId
1449 
    """
1450 
    self.send_getOrderCount(statuses, warehouseId)
1451 
    return self.recv_getOrderCount()
1452 
 
1453 
  def send_getOrderCount(self, statuses, warehouseId):
1454 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1455 
    args = getOrderCount_args()
1456 
    args.statuses = statuses
1457 
    args.warehouseId = warehouseId
1458 
    args.write(self._oprot)
1459 
    self._oprot.writeMessageEnd()
1460 
    self._oprot.trans.flush()
1461 
 
1462 
  def recv_getOrderCount(self, ):
1463 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1464 
    if mtype == TMessageType.EXCEPTION:
1465 
      x = TApplicationException()
1466 
      x.read(self._iprot)
1467 
      self._iprot.readMessageEnd()
1468 
      raise x
1469 
    result = getOrderCount_result()
1470 
    result.read(self._iprot)
1471 
    self._iprot.readMessageEnd()
1472 
    if result.success is not None:
1473 
      return result.success
1474 
    if result.ex is not None:
1475 
      raise result.ex
1476 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1477 
 
999 varun.gupt 1478 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1479 
    """
1132 chandransh 1480 
    Returns orders within a range of their billing dates
3431 rajveer 1481 
 
999 varun.gupt 1482 
    Parameters:
1483 
     - status
1484 
     - start_billing_date
1485 
     - end_billing_date
1486 
     - warehouse_id
1487 
    """
1488 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1489 
    return self.recv_getOrdersByBillingDate()
1490 
 
1491 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1492 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1493 
    args = getOrdersByBillingDate_args()
1494 
    args.status = status
1495 
    args.start_billing_date = start_billing_date
1496 
    args.end_billing_date = end_billing_date
1497 
    args.warehouse_id = warehouse_id
1498 
    args.write(self._oprot)
1499 
    self._oprot.writeMessageEnd()
1500 
    self._oprot.trans.flush()
1501 
 
1502 
  def recv_getOrdersByBillingDate(self, ):
1503 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1504 
    if mtype == TMessageType.EXCEPTION:
1505 
      x = TApplicationException()
1506 
      x.read(self._iprot)
1507 
      self._iprot.readMessageEnd()
1508 
      raise x
1509 
    result = getOrdersByBillingDate_result()
1510 
    result.read(self._iprot)
1511 
    self._iprot.readMessageEnd()
3431 rajveer 1512 
    if result.success is not None:
999 varun.gupt 1513 
      return result.success
3431 rajveer 1514 
    if result.ex is not None:
999 varun.gupt 1515 
      raise result.ex
1516 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1517 
 
3451 chandransh 1518 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1519 
    """
1520 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1521 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1522 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1523 
 
3427 chandransh 1524 
    Parameters:
1525 
     - fromShippingDate
1526 
     - toShippingDate
1527 
     - providerId
1528 
     - warehouseId
3451 chandransh 1529 
     - cod
3427 chandransh 1530 
    """
3451 chandransh 1531 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1532 
    return self.recv_getOrdersByShippingDate()
1533 
 
3451 chandransh 1534 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1535 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1536 
    args = getOrdersByShippingDate_args()
1537 
    args.fromShippingDate = fromShippingDate
1538 
    args.toShippingDate = toShippingDate
1539 
    args.providerId = providerId
1540 
    args.warehouseId = warehouseId
3451 chandransh 1541 
    args.cod = cod
3427 chandransh 1542 
    args.write(self._oprot)
1543 
    self._oprot.writeMessageEnd()
1544 
    self._oprot.trans.flush()
1545 
 
1546 
  def recv_getOrdersByShippingDate(self, ):
1547 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1548 
    if mtype == TMessageType.EXCEPTION:
1549 
      x = TApplicationException()
1550 
      x.read(self._iprot)
1551 
      self._iprot.readMessageEnd()
1552 
      raise x
1553 
    result = getOrdersByShippingDate_result()
1554 
    result.read(self._iprot)
1555 
    self._iprot.readMessageEnd()
3431 rajveer 1556 
    if result.success is not None:
3427 chandransh 1557 
      return result.success
3431 rajveer 1558 
    if result.ex is not None:
3427 chandransh 1559 
      raise result.ex
1560 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1561 
 
1382 varun.gupt 1562 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1563 
    """
1564 
    Returns order ids for orders which can be returned
3431 rajveer 1565 
 
1382 varun.gupt 1566 
    Parameters:
1567 
     - customer_id
1568 
     - limit
1569 
    """
1570 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1571 
    return self.recv_getReturnableOrdersForCustomer()
1572 
 
1573 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1574 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1575 
    args = getReturnableOrdersForCustomer_args()
1576 
    args.customer_id = customer_id
1577 
    args.limit = limit
1578 
    args.write(self._oprot)
1579 
    self._oprot.writeMessageEnd()
1580 
    self._oprot.trans.flush()
1581 
 
1582 
  def recv_getReturnableOrdersForCustomer(self, ):
1583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1584 
    if mtype == TMessageType.EXCEPTION:
1585 
      x = TApplicationException()
1586 
      x.read(self._iprot)
1587 
      self._iprot.readMessageEnd()
1588 
      raise x
1589 
    result = getReturnableOrdersForCustomer_result()
1590 
    result.read(self._iprot)
1591 
    self._iprot.readMessageEnd()
3431 rajveer 1592 
    if result.success is not None:
1382 varun.gupt 1593 
      return result.success
3431 rajveer 1594 
    if result.ex is not None:
1382 varun.gupt 1595 
      raise result.ex
1596 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1597 
 
1598 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1599 
    """
1600 
    Returns order ids for orders which can be cancelled
3431 rajveer 1601 
 
1382 varun.gupt 1602 
    Parameters:
1603 
     - customer_id
1604 
     - limit
1605 
    """
1606 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1607 
    return self.recv_getCancellableOrdersForCustomer()
1608 
 
1609 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1610 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1611 
    args = getCancellableOrdersForCustomer_args()
1612 
    args.customer_id = customer_id
1613 
    args.limit = limit
1614 
    args.write(self._oprot)
1615 
    self._oprot.writeMessageEnd()
1616 
    self._oprot.trans.flush()
1617 
 
1618 
  def recv_getCancellableOrdersForCustomer(self, ):
1619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1620 
    if mtype == TMessageType.EXCEPTION:
1621 
      x = TApplicationException()
1622 
      x.read(self._iprot)
1623 
      self._iprot.readMessageEnd()
1624 
      raise x
1625 
    result = getCancellableOrdersForCustomer_result()
1626 
    result.read(self._iprot)
1627 
    self._iprot.readMessageEnd()
3431 rajveer 1628 
    if result.success is not None:
1382 varun.gupt 1629 
      return result.success
3431 rajveer 1630 
    if result.ex is not None:
1382 varun.gupt 1631 
      raise result.ex
1632 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1633 
 
483 rajveer 1634 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1635 
    """
1636 
    Parameters:
483 rajveer 1637 
     - orderId
1638 
     - status
1639 
     - description
94 ashish 1640 
    """
483 rajveer 1641 
    self.send_changeOrderStatus(orderId, status, description)
1642 
    return self.recv_changeOrderStatus()
94 ashish 1643 
 
483 rajveer 1644 
  def send_changeOrderStatus(self, orderId, status, description):
1645 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1646 
    args = changeOrderStatus_args()
1647 
    args.orderId = orderId
1648 
    args.status = status
1649 
    args.description = description
94 ashish 1650 
    args.write(self._oprot)
1651 
    self._oprot.writeMessageEnd()
1652 
    self._oprot.trans.flush()
1653 
 
483 rajveer 1654 
  def recv_changeOrderStatus(self, ):
94 ashish 1655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1656 
    if mtype == TMessageType.EXCEPTION:
1657 
      x = TApplicationException()
1658 
      x.read(self._iprot)
1659 
      self._iprot.readMessageEnd()
1660 
      raise x
483 rajveer 1661 
    result = changeOrderStatus_result()
94 ashish 1662 
    result.read(self._iprot)
1663 
    self._iprot.readMessageEnd()
3431 rajveer 1664 
    if result.success is not None:
94 ashish 1665 
      return result.success
3431 rajveer 1666 
    if result.ex is not None:
94 ashish 1667 
      raise result.ex
483 rajveer 1668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1669 
 
1528 ankur.sing 1670 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1671 
    """
1528 ankur.sing 1672 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1673 
    only user who owns the transaction can view its order details.
3431 rajveer 1674 
 
94 ashish 1675 
    Parameters:
1676 
     - transactionId
1528 ankur.sing 1677 
     - customerId
94 ashish 1678 
    """
1528 ankur.sing 1679 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1680 
    return self.recv_getOrdersForTransaction()
94 ashish 1681 
 
1528 ankur.sing 1682 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1683 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1684 
    args = getOrdersForTransaction_args()
94 ashish 1685 
    args.transactionId = transactionId
1528 ankur.sing 1686 
    args.customerId = customerId
94 ashish 1687 
    args.write(self._oprot)
1688 
    self._oprot.writeMessageEnd()
1689 
    self._oprot.trans.flush()
1690 
 
483 rajveer 1691 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1692 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1693 
    if mtype == TMessageType.EXCEPTION:
1694 
      x = TApplicationException()
1695 
      x.read(self._iprot)
1696 
      self._iprot.readMessageEnd()
1697 
      raise x
483 rajveer 1698 
    result = getOrdersForTransaction_result()
94 ashish 1699 
    result.read(self._iprot)
1700 
    self._iprot.readMessageEnd()
3431 rajveer 1701 
    if result.success is not None:
94 ashish 1702 
      return result.success
3431 rajveer 1703 
    if result.ex is not None:
94 ashish 1704 
      raise result.ex
483 rajveer 1705 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1706 
 
3014 chandransh 1707 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1708 
    """
3014 chandransh 1709 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1710 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1711 
 
94 ashish 1712 
    Parameters:
483 rajveer 1713 
     - customerId
1714 
     - from_date
1715 
     - to_date
3014 chandransh 1716 
     - statuses
94 ashish 1717 
    """
3014 chandransh 1718 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1719 
    return self.recv_getOrdersForCustomer()
94 ashish 1720 
 
3014 chandransh 1721 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1722 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1723 
    args = getOrdersForCustomer_args()
1724 
    args.customerId = customerId
1725 
    args.from_date = from_date
1726 
    args.to_date = to_date
3014 chandransh 1727 
    args.statuses = statuses
94 ashish 1728 
    args.write(self._oprot)
1729 
    self._oprot.writeMessageEnd()
1730 
    self._oprot.trans.flush()
1731 
 
483 rajveer 1732 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1734 
    if mtype == TMessageType.EXCEPTION:
1735 
      x = TApplicationException()
1736 
      x.read(self._iprot)
1737 
      self._iprot.readMessageEnd()
1738 
      raise x
483 rajveer 1739 
    result = getOrdersForCustomer_result()
94 ashish 1740 
    result.read(self._iprot)
1741 
    self._iprot.readMessageEnd()
3431 rajveer 1742 
    if result.success is not None:
94 ashish 1743 
      return result.success
3431 rajveer 1744 
    if result.ex is not None:
94 ashish 1745 
      raise result.ex
483 rajveer 1746 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1747 
 
483 rajveer 1748 
  def createOrder(self, order):
94 ashish 1749 
    """
1750 
    Parameters:
483 rajveer 1751 
     - order
94 ashish 1752 
    """
483 rajveer 1753 
    self.send_createOrder(order)
1754 
    return self.recv_createOrder()
94 ashish 1755 
 
483 rajveer 1756 
  def send_createOrder(self, order):
1757 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1758 
    args = createOrder_args()
1759 
    args.order = order
94 ashish 1760 
    args.write(self._oprot)
1761 
    self._oprot.writeMessageEnd()
1762 
    self._oprot.trans.flush()
1763 
 
483 rajveer 1764 
  def recv_createOrder(self, ):
94 ashish 1765 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1766 
    if mtype == TMessageType.EXCEPTION:
1767 
      x = TApplicationException()
1768 
      x.read(self._iprot)
1769 
      self._iprot.readMessageEnd()
1770 
      raise x
483 rajveer 1771 
    result = createOrder_result()
94 ashish 1772 
    result.read(self._iprot)
1773 
    self._iprot.readMessageEnd()
3431 rajveer 1774 
    if result.success is not None:
94 ashish 1775 
      return result.success
3431 rajveer 1776 
    if result.ex is not None:
94 ashish 1777 
      raise result.ex
483 rajveer 1778 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1779 
 
483 rajveer 1780 
  def getOrder(self, id):
94 ashish 1781 
    """
1782 
    Parameters:
483 rajveer 1783 
     - id
94 ashish 1784 
    """
483 rajveer 1785 
    self.send_getOrder(id)
1786 
    return self.recv_getOrder()
94 ashish 1787 
 
483 rajveer 1788 
  def send_getOrder(self, id):
1789 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1790 
    args = getOrder_args()
1791 
    args.id = id
94 ashish 1792 
    args.write(self._oprot)
1793 
    self._oprot.writeMessageEnd()
1794 
    self._oprot.trans.flush()
1795 
 
483 rajveer 1796 
  def recv_getOrder(self, ):
94 ashish 1797 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1798 
    if mtype == TMessageType.EXCEPTION:
1799 
      x = TApplicationException()
1800 
      x.read(self._iprot)
1801 
      self._iprot.readMessageEnd()
1802 
      raise x
483 rajveer 1803 
    result = getOrder_result()
94 ashish 1804 
    result.read(self._iprot)
1805 
    self._iprot.readMessageEnd()
3431 rajveer 1806 
    if result.success is not None:
94 ashish 1807 
      return result.success
3431 rajveer 1808 
    if result.ex is not None:
94 ashish 1809 
      raise result.ex
483 rajveer 1810 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1811 
 
483 rajveer 1812 
  def getLineItemsForOrder(self, orderId):
94 ashish 1813 
    """
1814 
    Parameters:
483 rajveer 1815 
     - orderId
94 ashish 1816 
    """
483 rajveer 1817 
    self.send_getLineItemsForOrder(orderId)
1818 
    return self.recv_getLineItemsForOrder()
94 ashish 1819 
 
483 rajveer 1820 
  def send_getLineItemsForOrder(self, orderId):
1821 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1822 
    args = getLineItemsForOrder_args()
1823 
    args.orderId = orderId
94 ashish 1824 
    args.write(self._oprot)
1825 
    self._oprot.writeMessageEnd()
1826 
    self._oprot.trans.flush()
1827 
 
483 rajveer 1828 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1830 
    if mtype == TMessageType.EXCEPTION:
1831 
      x = TApplicationException()
1832 
      x.read(self._iprot)
1833 
      self._iprot.readMessageEnd()
1834 
      raise x
483 rajveer 1835 
    result = getLineItemsForOrder_result()
94 ashish 1836 
    result.read(self._iprot)
1837 
    self._iprot.readMessageEnd()
3431 rajveer 1838 
    if result.success is not None:
94 ashish 1839 
      return result.success
3431 rajveer 1840 
    if result.ex is not None:
94 ashish 1841 
      raise result.ex
483 rajveer 1842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1843 
 
4999 phani.kuma 1844 
  def getOrderList(self, order_ids):
1845 
    """
1846 
    Parameters:
1847 
     - order_ids
1848 
    """
1849 
    self.send_getOrderList(order_ids)
1850 
    return self.recv_getOrderList()
1851 
 
1852 
  def send_getOrderList(self, order_ids):
1853 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
1854 
    args = getOrderList_args()
1855 
    args.order_ids = order_ids
1856 
    args.write(self._oprot)
1857 
    self._oprot.writeMessageEnd()
1858 
    self._oprot.trans.flush()
1859 
 
1860 
  def recv_getOrderList(self, ):
1861 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1862 
    if mtype == TMessageType.EXCEPTION:
1863 
      x = TApplicationException()
1864 
      x.read(self._iprot)
1865 
      self._iprot.readMessageEnd()
1866 
      raise x
1867 
    result = getOrderList_result()
1868 
    result.read(self._iprot)
1869 
    self._iprot.readMessageEnd()
1870 
    if result.success is not None:
1871 
      return result.success
1872 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
1873 
 
1528 ankur.sing 1874 
  def getOrderForCustomer(self, orderId, customerId):
1875 
    """
1876 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1877 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1878 
 
1528 ankur.sing 1879 
    Parameters:
1880 
     - orderId
1881 
     - customerId
1882 
    """
1883 
    self.send_getOrderForCustomer(orderId, customerId)
1884 
    return self.recv_getOrderForCustomer()
1885 
 
1886 
  def send_getOrderForCustomer(self, orderId, customerId):
1887 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1888 
    args = getOrderForCustomer_args()
1889 
    args.orderId = orderId
1890 
    args.customerId = customerId
1891 
    args.write(self._oprot)
1892 
    self._oprot.writeMessageEnd()
1893 
    self._oprot.trans.flush()
1894 
 
1895 
  def recv_getOrderForCustomer(self, ):
1896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1897 
    if mtype == TMessageType.EXCEPTION:
1898 
      x = TApplicationException()
1899 
      x.read(self._iprot)
1900 
      self._iprot.readMessageEnd()
1901 
      raise x
1902 
    result = getOrderForCustomer_result()
1903 
    result.read(self._iprot)
1904 
    self._iprot.readMessageEnd()
3431 rajveer 1905 
    if result.success is not None:
1528 ankur.sing 1906 
      return result.success
3431 rajveer 1907 
    if result.ex is not None:
1528 ankur.sing 1908 
      raise result.ex
1909 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1910 
 
4444 rajveer 1911 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1912 
    """
1913 
    Parameters:
4394 rajveer 1914 
     - type
4444 rajveer 1915 
     - warehouseId
4394 rajveer 1916 
     - status
1917 
     - timestamp
3064 chandransh 1918 
    """
4444 rajveer 1919 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1920 
    return self.recv_getAlerts()
1921 
 
4444 rajveer 1922 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1923 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1924 
    args = getAlerts_args()
4394 rajveer 1925 
    args.type = type
4444 rajveer 1926 
    args.warehouseId = warehouseId
4394 rajveer 1927 
    args.status = status
1928 
    args.timestamp = timestamp
3064 chandransh 1929 
    args.write(self._oprot)
1930 
    self._oprot.writeMessageEnd()
1931 
    self._oprot.trans.flush()
1932 
 
1933 
  def recv_getAlerts(self, ):
1934 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1935 
    if mtype == TMessageType.EXCEPTION:
1936 
      x = TApplicationException()
1937 
      x.read(self._iprot)
1938 
      self._iprot.readMessageEnd()
1939 
      raise x
1940 
    result = getAlerts_result()
1941 
    result.read(self._iprot)
1942 
    self._iprot.readMessageEnd()
3431 rajveer 1943 
    if result.success is not None:
3064 chandransh 1944 
      return result.success
1945 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1946 
 
4444 rajveer 1947 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1948 
    """
1949 
    Parameters:
1950 
     - type
4444 rajveer 1951 
     - warehouseId
4394 rajveer 1952 
     - description
3064 chandransh 1953 
    """
4444 rajveer 1954 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1955 
    self.recv_addAlert()
3064 chandransh 1956 
 
4444 rajveer 1957 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1958 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1959 
    args = addAlert_args()
3064 chandransh 1960 
    args.type = type
4444 rajveer 1961 
    args.warehouseId = warehouseId
4394 rajveer 1962 
    args.description = description
3064 chandransh 1963 
    args.write(self._oprot)
1964 
    self._oprot.writeMessageEnd()
1965 
    self._oprot.trans.flush()
1966 
 
4394 rajveer 1967 
  def recv_addAlert(self, ):
3064 chandransh 1968 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1969 
    if mtype == TMessageType.EXCEPTION:
1970 
      x = TApplicationException()
1971 
      x.read(self._iprot)
1972 
      self._iprot.readMessageEnd()
1973 
      raise x
4394 rajveer 1974 
    result = addAlert_result()
3064 chandransh 1975 
    result.read(self._iprot)
1976 
    self._iprot.readMessageEnd()
1977 
    return
1978 
 
4444 rajveer 1979 
  def markAlertsAsSeen(self, warehouseId):
1980 
    """
1981 
    Parameters:
1982 
     - warehouseId
1983 
    """
1984 
    self.send_markAlertsAsSeen(warehouseId)
1985 
    self.recv_markAlertsAsSeen()
1986 
 
1987 
  def send_markAlertsAsSeen(self, warehouseId):
1988 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1989 
    args = markAlertsAsSeen_args()
1990 
    args.warehouseId = warehouseId
1991 
    args.write(self._oprot)
1992 
    self._oprot.writeMessageEnd()
1993 
    self._oprot.trans.flush()
1994 
 
1995 
  def recv_markAlertsAsSeen(self, ):
1996 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1997 
    if mtype == TMessageType.EXCEPTION:
1998 
      x = TApplicationException()
1999 
      x.read(self._iprot)
2000 
      self._iprot.readMessageEnd()
2001 
      raise x
2002 
    result = markAlertsAsSeen_result()
2003 
    result.read(self._iprot)
2004 
    self._iprot.readMessageEnd()
2005 
    return
2006 
 
3064 chandransh 2007 
  def getValidOrderCount(self, ):
2008 
    """
2009 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2010 
    """
2011 
    self.send_getValidOrderCount()
2012 
    return self.recv_getValidOrderCount()
2013 
 
2014 
  def send_getValidOrderCount(self, ):
2015 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2016 
    args = getValidOrderCount_args()
2017 
    args.write(self._oprot)
2018 
    self._oprot.writeMessageEnd()
2019 
    self._oprot.trans.flush()
2020 
 
2021 
  def recv_getValidOrderCount(self, ):
2022 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2023 
    if mtype == TMessageType.EXCEPTION:
2024 
      x = TApplicationException()
2025 
      x.read(self._iprot)
2026 
      self._iprot.readMessageEnd()
2027 
      raise x
2028 
    result = getValidOrderCount_result()
2029 
    result.read(self._iprot)
2030 
    self._iprot.readMessageEnd()
3431 rajveer 2031 
    if result.success is not None:
3064 chandransh 2032 
      return result.success
2033 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2034 
 
2035 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2036 
    """
2037 
    Returns the number of distinct customers who have done successful transactions
2038 
    """
2039 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2040 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2041 
 
2042 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2043 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2044 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2045 
    args.write(self._oprot)
2046 
    self._oprot.writeMessageEnd()
2047 
    self._oprot.trans.flush()
2048 
 
2049 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2051 
    if mtype == TMessageType.EXCEPTION:
2052 
      x = TApplicationException()
2053 
      x.read(self._iprot)
2054 
      self._iprot.readMessageEnd()
2055 
      raise x
2056 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2057 
    result.read(self._iprot)
2058 
    self._iprot.readMessageEnd()
3431 rajveer 2059 
    if result.success is not None:
3064 chandransh 2060 
      return result.success
2061 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2062 
 
2063 
  def getValidOrdersAmountRange(self, ):
2064 
    """
2065 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2066 
    List contains two values, first minimum amount and second maximum amount.
2067 
    """
2068 
    self.send_getValidOrdersAmountRange()
2069 
    return self.recv_getValidOrdersAmountRange()
2070 
 
2071 
  def send_getValidOrdersAmountRange(self, ):
2072 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2073 
    args = getValidOrdersAmountRange_args()
2074 
    args.write(self._oprot)
2075 
    self._oprot.writeMessageEnd()
2076 
    self._oprot.trans.flush()
2077 
 
2078 
  def recv_getValidOrdersAmountRange(self, ):
2079 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2080 
    if mtype == TMessageType.EXCEPTION:
2081 
      x = TApplicationException()
2082 
      x.read(self._iprot)
2083 
      self._iprot.readMessageEnd()
2084 
      raise x
2085 
    result = getValidOrdersAmountRange_result()
2086 
    result.read(self._iprot)
2087 
    self._iprot.readMessageEnd()
3431 rajveer 2088 
    if result.success is not None:
3064 chandransh 2089 
      return result.success
2090 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2091 
 
2092 
  def getValidOrders(self, limit):
2093 
    """
2094 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2095 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2096 
 
3064 chandransh 2097 
    Parameters:
2098 
     - limit
2099 
    """
2100 
    self.send_getValidOrders(limit)
2101 
    return self.recv_getValidOrders()
2102 
 
2103 
  def send_getValidOrders(self, limit):
2104 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2105 
    args = getValidOrders_args()
2106 
    args.limit = limit
2107 
    args.write(self._oprot)
2108 
    self._oprot.writeMessageEnd()
2109 
    self._oprot.trans.flush()
2110 
 
2111 
  def recv_getValidOrders(self, ):
2112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2113 
    if mtype == TMessageType.EXCEPTION:
2114 
      x = TApplicationException()
2115 
      x.read(self._iprot)
2116 
      self._iprot.readMessageEnd()
2117 
      raise x
2118 
    result = getValidOrders_result()
2119 
    result.read(self._iprot)
2120 
    self._iprot.readMessageEnd()
3431 rajveer 2121 
    if result.success is not None:
3064 chandransh 2122 
      return result.success
2123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2124 
 
1220 chandransh 2125 
  def batchOrders(self, warehouseId):
2126 
    """
2127 
    Create a batch of all the pending orders for the given warehouse.
2128 
    The returned list is orderd by created_timestamp.
2129 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2130 
 
1220 chandransh 2131 
    Parameters:
2132 
     - warehouseId
2133 
    """
2134 
    self.send_batchOrders(warehouseId)
2135 
    return self.recv_batchOrders()
2136 
 
2137 
  def send_batchOrders(self, warehouseId):
2138 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2139 
    args = batchOrders_args()
2140 
    args.warehouseId = warehouseId
2141 
    args.write(self._oprot)
2142 
    self._oprot.writeMessageEnd()
2143 
    self._oprot.trans.flush()
2144 
 
2145 
  def recv_batchOrders(self, ):
2146 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2147 
    if mtype == TMessageType.EXCEPTION:
2148 
      x = TApplicationException()
2149 
      x.read(self._iprot)
2150 
      self._iprot.readMessageEnd()
2151 
      raise x
2152 
    result = batchOrders_result()
2153 
    result.read(self._iprot)
2154 
    self._iprot.readMessageEnd()
3431 rajveer 2155 
    if result.success is not None:
1220 chandransh 2156 
      return result.success
3431 rajveer 2157 
    if result.ex is not None:
1220 chandransh 2158 
      raise result.ex
2159 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2160 
 
1208 chandransh 2161 
  def markOrderAsOutOfStock(self, orderId):
2162 
    """
2163 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2164 
 
1208 chandransh 2165 
    Parameters:
2166 
     - orderId
2167 
    """
2168 
    self.send_markOrderAsOutOfStock(orderId)
2169 
    return self.recv_markOrderAsOutOfStock()
2170 
 
2171 
  def send_markOrderAsOutOfStock(self, orderId):
2172 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2173 
    args = markOrderAsOutOfStock_args()
2174 
    args.orderId = orderId
2175 
    args.write(self._oprot)
2176 
    self._oprot.writeMessageEnd()
2177 
    self._oprot.trans.flush()
2178 
 
2179 
  def recv_markOrderAsOutOfStock(self, ):
2180 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2181 
    if mtype == TMessageType.EXCEPTION:
2182 
      x = TApplicationException()
2183 
      x.read(self._iprot)
2184 
      self._iprot.readMessageEnd()
2185 
      raise x
2186 
    result = markOrderAsOutOfStock_result()
2187 
    result.read(self._iprot)
2188 
    self._iprot.readMessageEnd()
3431 rajveer 2189 
    if result.success is not None:
1208 chandransh 2190 
      return result.success
3431 rajveer 2191 
    if result.ex is not None:
1208 chandransh 2192 
      raise result.ex
2193 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2194 
 
3064 chandransh 2195 
  def verifyOrder(self, orderId):
759 chandransh 2196 
    """
3064 chandransh 2197 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2198 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2199 
    used for all other orders as well.
2200 
    Throws an exception if no such order exists.
3431 rajveer 2201 
 
759 chandransh 2202 
    Parameters:
3064 chandransh 2203 
     - orderId
759 chandransh 2204 
    """
3064 chandransh 2205 
    self.send_verifyOrder(orderId)
2206 
    return self.recv_verifyOrder()
759 chandransh 2207 
 
3064 chandransh 2208 
  def send_verifyOrder(self, orderId):
2209 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2210 
    args = verifyOrder_args()
2211 
    args.orderId = orderId
759 chandransh 2212 
    args.write(self._oprot)
2213 
    self._oprot.writeMessageEnd()
2214 
    self._oprot.trans.flush()
2215 
 
3064 chandransh 2216 
  def recv_verifyOrder(self, ):
759 chandransh 2217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2218 
    if mtype == TMessageType.EXCEPTION:
2219 
      x = TApplicationException()
2220 
      x.read(self._iprot)
2221 
      self._iprot.readMessageEnd()
2222 
      raise x
3064 chandransh 2223 
    result = verifyOrder_result()
759 chandransh 2224 
    result.read(self._iprot)
2225 
    self._iprot.readMessageEnd()
3431 rajveer 2226 
    if result.success is not None:
759 chandransh 2227 
      return result.success
3431 rajveer 2228 
    if result.ex is not None:
759 chandransh 2229 
      raise result.ex
3064 chandransh 2230 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2231 
 
3064 chandransh 2232 
  def acceptOrder(self, orderId):
1113 chandransh 2233 
    """
3064 chandransh 2234 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2235 
    given order is not a COD order, it also captures the payment if the same has
2236 
    not been captured.
2237 
    Throws an exception if no such order exists.
3431 rajveer 2238 
 
1113 chandransh 2239 
    Parameters:
3064 chandransh 2240 
     - orderId
1113 chandransh 2241 
    """
3064 chandransh 2242 
    self.send_acceptOrder(orderId)
2243 
    return self.recv_acceptOrder()
1113 chandransh 2244 
 
3064 chandransh 2245 
  def send_acceptOrder(self, orderId):
2246 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2247 
    args = acceptOrder_args()
2248 
    args.orderId = orderId
1113 chandransh 2249 
    args.write(self._oprot)
2250 
    self._oprot.writeMessageEnd()
2251 
    self._oprot.trans.flush()
2252 
 
3064 chandransh 2253 
  def recv_acceptOrder(self, ):
1113 chandransh 2254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2255 
    if mtype == TMessageType.EXCEPTION:
2256 
      x = TApplicationException()
2257 
      x.read(self._iprot)
2258 
      self._iprot.readMessageEnd()
2259 
      raise x
3064 chandransh 2260 
    result = acceptOrder_result()
1113 chandransh 2261 
    result.read(self._iprot)
2262 
    self._iprot.readMessageEnd()
3431 rajveer 2263 
    if result.success is not None:
1113 chandransh 2264 
      return result.success
3431 rajveer 2265 
    if result.ex is not None:
1113 chandransh 2266 
      raise result.ex
3064 chandransh 2267 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2268 
 
4763 rajveer 2269 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
1132 chandransh 2270 
    """
3064 chandransh 2271 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2272 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2273 
    the IMEI no. if a -1 is supplied.
2274 
    Also, it generates an invoice number for the order, marks the order as
2275 
    BILLED and sets the billing timestamp.
2276 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2277 
 
1135 chandransh 2278 
    Parameters:
3064 chandransh 2279 
     - orderId
2280 
     - invoice_number
4658 mandeep.dh 2281 
     - serialNumber
4283 anupam.sin 2282 
     - itemNumber
3064 chandransh 2283 
     - billed_by
4264 rajveer 2284 
     - jacketNumber
4283 anupam.sin 2285 
     - billingType
2286 
     - vendorId
4763 rajveer 2287 
     - authorize
1135 chandransh 2288 
    """
4763 rajveer 2289 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize)
3064 chandransh 2290 
    return self.recv_addBillingDetails()
1135 chandransh 2291 
 
4763 rajveer 2292 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, vendorId, authorize):
3064 chandransh 2293 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2294 
    args = addBillingDetails_args()
2295 
    args.orderId = orderId
2296 
    args.invoice_number = invoice_number
4658 mandeep.dh 2297 
    args.serialNumber = serialNumber
4283 anupam.sin 2298 
    args.itemNumber = itemNumber
3064 chandransh 2299 
    args.billed_by = billed_by
4264 rajveer 2300 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2301 
    args.billingType = billingType
2302 
    args.vendorId = vendorId
4763 rajveer 2303 
    args.authorize = authorize
1135 chandransh 2304 
    args.write(self._oprot)
2305 
    self._oprot.writeMessageEnd()
2306 
    self._oprot.trans.flush()
2307 
 
3064 chandransh 2308 
  def recv_addBillingDetails(self, ):
1135 chandransh 2309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2310 
    if mtype == TMessageType.EXCEPTION:
2311 
      x = TApplicationException()
2312 
      x.read(self._iprot)
2313 
      self._iprot.readMessageEnd()
2314 
      raise x
3064 chandransh 2315 
    result = addBillingDetails_result()
1135 chandransh 2316 
    result.read(self._iprot)
2317 
    self._iprot.readMessageEnd()
3431 rajveer 2318 
    if result.success is not None:
3064 chandransh 2319 
      return result.success
3431 rajveer 2320 
    if result.ex is not None:
1135 chandransh 2321 
      raise result.ex
3064 chandransh 2322 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2323 
 
4763 rajveer 2324 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2325 
    """
2326 
    Add the invoice number to the order.
2327 
 
2328 
    Parameters:
2329 
     - orderId
2330 
     - invoiceNumber
4763 rajveer 2331 
     - color
4579 rajveer 2332 
    """
4763 rajveer 2333 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2334 
    self.recv_addInvoiceNumber()
2335 
 
4763 rajveer 2336 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2337 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2338 
    args = addInvoiceNumber_args()
2339 
    args.orderId = orderId
2340 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2341 
    args.color = color
4579 rajveer 2342 
    args.write(self._oprot)
2343 
    self._oprot.writeMessageEnd()
2344 
    self._oprot.trans.flush()
2345 
 
2346 
  def recv_addInvoiceNumber(self, ):
2347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2348 
    if mtype == TMessageType.EXCEPTION:
2349 
      x = TApplicationException()
2350 
      x.read(self._iprot)
2351 
      self._iprot.readMessageEnd()
2352 
      raise x
2353 
    result = addInvoiceNumber_result()
2354 
    result.read(self._iprot)
2355 
    self._iprot.readMessageEnd()
2356 
    if result.ex is not None:
2357 
      raise result.ex
2358 
    return
2359 
 
4910 phani.kuma 2360 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2361 
    """
3064 chandransh 2362 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2363 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2364 
 
1408 ankur.sing 2365 
    Parameters:
3064 chandransh 2366 
     - warehouseId
1408 ankur.sing 2367 
     - providerId
3064 chandransh 2368 
     - cod
4910 phani.kuma 2369 
     - orderIds
1408 ankur.sing 2370 
    """
4910 phani.kuma 2371 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2372 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2373 
 
4910 phani.kuma 2374 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2375 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2376 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2377 
    args.warehouseId = warehouseId
1408 ankur.sing 2378 
    args.providerId = providerId
3064 chandransh 2379 
    args.cod = cod
4910 phani.kuma 2380 
    args.orderIds = orderIds
1408 ankur.sing 2381 
    args.write(self._oprot)
2382 
    self._oprot.writeMessageEnd()
2383 
    self._oprot.trans.flush()
2384 
 
4910 phani.kuma 2385 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2387 
    if mtype == TMessageType.EXCEPTION:
2388 
      x = TApplicationException()
2389 
      x.read(self._iprot)
2390 
      self._iprot.readMessageEnd()
2391 
      raise x
4910 phani.kuma 2392 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2393 
    result.read(self._iprot)
2394 
    self._iprot.readMessageEnd()
3431 rajveer 2395 
    if result.success is not None:
1408 ankur.sing 2396 
      return result.success
3431 rajveer 2397 
    if result.ex is not None:
3064 chandransh 2398 
      raise result.ex
4910 phani.kuma 2399 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2400 
 
4910 phani.kuma 2401 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2402 
    """
4910 phani.kuma 2403 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2404 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2405 
 
2406 
    Parameters:
2407 
     - providerId
4910 phani.kuma 2408 
     - pickupDetails
4410 rajveer 2409 
    """
4910 phani.kuma 2410 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2411 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2412 
 
4910 phani.kuma 2413 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2414 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2415 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2416 
    args.providerId = providerId
4910 phani.kuma 2417 
    args.pickupDetails = pickupDetails
4410 rajveer 2418 
    args.write(self._oprot)
2419 
    self._oprot.writeMessageEnd()
2420 
    self._oprot.trans.flush()
2421 
 
4910 phani.kuma 2422 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2423 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2424 
    if mtype == TMessageType.EXCEPTION:
2425 
      x = TApplicationException()
2426 
      x.read(self._iprot)
2427 
      self._iprot.readMessageEnd()
2428 
      raise x
4910 phani.kuma 2429 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2430 
    result.read(self._iprot)
2431 
    self._iprot.readMessageEnd()
2432 
    if result.ex is not None:
2433 
      raise result.ex
4910 phani.kuma 2434 
    return
4410 rajveer 2435 
 
4910 phani.kuma 2436 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2437 
    """
3064 chandransh 2438 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2439 
 
94 ashish 2440 
    Parameters:
3064 chandransh 2441 
     - providerId
304 ashish 2442 
    """
4910 phani.kuma 2443 
    self.send_getOrdersNotPickedUp(providerId)
2444 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2445 
 
4910 phani.kuma 2446 
  def send_getOrdersNotPickedUp(self, providerId):
2447 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2448 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2449 
    args.providerId = providerId
304 ashish 2450 
    args.write(self._oprot)
2451 
    self._oprot.writeMessageEnd()
2452 
    self._oprot.trans.flush()
2453 
 
4910 phani.kuma 2454 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2455 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2456 
    if mtype == TMessageType.EXCEPTION:
2457 
      x = TApplicationException()
2458 
      x.read(self._iprot)
2459 
      self._iprot.readMessageEnd()
2460 
      raise x
4910 phani.kuma 2461 
    result = getOrdersNotPickedUp_result()
304 ashish 2462 
    result.read(self._iprot)
2463 
    self._iprot.readMessageEnd()
3431 rajveer 2464 
    if result.success is not None:
304 ashish 2465 
      return result.success
4910 phani.kuma 2466 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2467 
 
3064 chandransh 2468 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2469 
    """
3064 chandransh 2470 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2471 
    the name of the receiver.
2472 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2473 
 
304 ashish 2474 
    Parameters:
3064 chandransh 2475 
     - providerId
2476 
     - deliveredOrders
304 ashish 2477 
    """
3064 chandransh 2478 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2479 
    self.recv_markOrdersAsDelivered()
304 ashish 2480 
 
3064 chandransh 2481 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2482 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2483 
    args = markOrdersAsDelivered_args()
2484 
    args.providerId = providerId
2485 
    args.deliveredOrders = deliveredOrders
304 ashish 2486 
    args.write(self._oprot)
2487 
    self._oprot.writeMessageEnd()
2488 
    self._oprot.trans.flush()
2489 
 
3064 chandransh 2490 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2491 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2492 
    if mtype == TMessageType.EXCEPTION:
2493 
      x = TApplicationException()
2494 
      x.read(self._iprot)
2495 
      self._iprot.readMessageEnd()
2496 
      raise x
3064 chandransh 2497 
    result = markOrdersAsDelivered_result()
304 ashish 2498 
    result.read(self._iprot)
2499 
    self._iprot.readMessageEnd()
3431 rajveer 2500 
    if result.ex is not None:
3064 chandransh 2501 
      raise result.ex
304 ashish 2502 
    return
2503 
 
4910 phani.kuma 2504 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2505 
    """
4910 phani.kuma 2506 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2507 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2508 
 
3064 chandransh 2509 
    Parameters:
2510 
     - providerId
2511 
     - returnedOrders
1596 ankur.sing 2512 
    """
4910 phani.kuma 2513 
    self.send_markAsRTOrders(providerId, returnedOrders)
2514 
    self.recv_markAsRTOrders()
304 ashish 2515 
 
4910 phani.kuma 2516 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2517 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2518 
    args = markAsRTOrders_args()
3064 chandransh 2519 
    args.providerId = providerId
2520 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2521 
    args.write(self._oprot)
2522 
    self._oprot.writeMessageEnd()
2523 
    self._oprot.trans.flush()
2524 
 
4910 phani.kuma 2525 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2526 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2527 
    if mtype == TMessageType.EXCEPTION:
2528 
      x = TApplicationException()
2529 
      x.read(self._iprot)
2530 
      self._iprot.readMessageEnd()
2531 
      raise x
4910 phani.kuma 2532 
    result = markAsRTOrders_result()
1596 ankur.sing 2533 
    result.read(self._iprot)
2534 
    self._iprot.readMessageEnd()
3431 rajveer 2535 
    if result.ex is not None:
3064 chandransh 2536 
      raise result.ex
2537 
    return
1596 ankur.sing 2538 
 
4910 phani.kuma 2539 
  def getRTOrders(self, providerId):
2540 
    """
2541 
    Returns a list of orders that were returned by courier.
2542 
 
2543 
    Parameters:
2544 
     - providerId
2545 
    """
2546 
    self.send_getRTOrders(providerId)
2547 
    return self.recv_getRTOrders()
2548 
 
2549 
  def send_getRTOrders(self, providerId):
2550 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2551 
    args = getRTOrders_args()
2552 
    args.providerId = providerId
2553 
    args.write(self._oprot)
2554 
    self._oprot.writeMessageEnd()
2555 
    self._oprot.trans.flush()
2556 
 
2557 
  def recv_getRTOrders(self, ):
2558 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2559 
    if mtype == TMessageType.EXCEPTION:
2560 
      x = TApplicationException()
2561 
      x.read(self._iprot)
2562 
      self._iprot.readMessageEnd()
2563 
      raise x
2564 
    result = getRTOrders_result()
2565 
    result.read(self._iprot)
2566 
    self._iprot.readMessageEnd()
2567 
    if result.success is not None:
2568 
      return result.success
2569 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2570 
 
3064 chandransh 2571 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2572 
    """
3064 chandransh 2573 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2574 
 
3064 chandransh 2575 
    Parameters:
2576 
     - providerId
2577 
     - undeliveredOrders
1627 ankur.sing 2578 
    """
3064 chandransh 2579 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2580 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2581 
 
3064 chandransh 2582 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2583 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2584 
    args = updateNonDeliveryReason_args()
2585 
    args.providerId = providerId
2586 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2587 
    args.write(self._oprot)
2588 
    self._oprot.writeMessageEnd()
2589 
    self._oprot.trans.flush()
2590 
 
3064 chandransh 2591 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2592 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2593 
    if mtype == TMessageType.EXCEPTION:
2594 
      x = TApplicationException()
2595 
      x.read(self._iprot)
2596 
      self._iprot.readMessageEnd()
2597 
      raise x
3064 chandransh 2598 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2599 
    result.read(self._iprot)
2600 
    self._iprot.readMessageEnd()
4910 phani.kuma 2601 
    if result.ex is not None:
2602 
      raise result.ex
2603 
    return
2604 
 
2605 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2606 
    """
2607 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2608 
 
2609 
    Parameters:
2610 
     - providerId
2611 
    """
2612 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2613 
    return self.recv_getNonDeliveredOrdersbyCourier()
2614 
 
2615 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2616 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2617 
    args = getNonDeliveredOrdersbyCourier_args()
2618 
    args.providerId = providerId
2619 
    args.write(self._oprot)
2620 
    self._oprot.writeMessageEnd()
2621 
    self._oprot.trans.flush()
2622 
 
2623 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2624 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2625 
    if mtype == TMessageType.EXCEPTION:
2626 
      x = TApplicationException()
2627 
      x.read(self._iprot)
2628 
      self._iprot.readMessageEnd()
2629 
      raise x
2630 
    result = getNonDeliveredOrdersbyCourier_result()
2631 
    result.read(self._iprot)
2632 
    self._iprot.readMessageEnd()
4581 phani.kuma 2633 
    if result.success is not None:
2634 
      return result.success
4910 phani.kuma 2635 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2636 
 
2637 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2638 
    """
2639 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2640 
 
2641 
    Parameters:
2642 
     - providerId
2643 
     - local_connected_orders
2644 
    """
2645 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2646 
    self.recv_markOrdersAsLocalConnected()
2647 
 
2648 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2649 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2650 
    args = markOrdersAsLocalConnected_args()
2651 
    args.providerId = providerId
2652 
    args.local_connected_orders = local_connected_orders
2653 
    args.write(self._oprot)
2654 
    self._oprot.writeMessageEnd()
2655 
    self._oprot.trans.flush()
2656 
 
2657 
  def recv_markOrdersAsLocalConnected(self, ):
2658 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2659 
    if mtype == TMessageType.EXCEPTION:
2660 
      x = TApplicationException()
2661 
      x.read(self._iprot)
2662 
      self._iprot.readMessageEnd()
2663 
      raise x
2664 
    result = markOrdersAsLocalConnected_result()
2665 
    result.read(self._iprot)
2666 
    self._iprot.readMessageEnd()
3431 rajveer 2667 
    if result.ex is not None:
3064 chandransh 2668 
      raise result.ex
4910 phani.kuma 2669 
    return
1627 ankur.sing 2670 
 
4910 phani.kuma 2671 
  def getOrdersNotLocalConnected(self, providerId):
2672 
    """
2673 
    Returns a list of orders that were picked up or shipped but pending local connection.
2674 
 
2675 
    Parameters:
2676 
     - providerId
2677 
    """
2678 
    self.send_getOrdersNotLocalConnected(providerId)
2679 
    return self.recv_getOrdersNotLocalConnected()
2680 
 
2681 
  def send_getOrdersNotLocalConnected(self, providerId):
2682 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2683 
    args = getOrdersNotLocalConnected_args()
2684 
    args.providerId = providerId
2685 
    args.write(self._oprot)
2686 
    self._oprot.writeMessageEnd()
2687 
    self._oprot.trans.flush()
2688 
 
2689 
  def recv_getOrdersNotLocalConnected(self, ):
2690 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2691 
    if mtype == TMessageType.EXCEPTION:
2692 
      x = TApplicationException()
2693 
      x.read(self._iprot)
2694 
      self._iprot.readMessageEnd()
2695 
      raise x
2696 
    result = getOrdersNotLocalConnected_result()
2697 
    result.read(self._iprot)
2698 
    self._iprot.readMessageEnd()
2699 
    if result.success is not None:
2700 
      return result.success
2701 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2702 
 
2703 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2704 
    """
2705 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2706 
 
2707 
    Parameters:
2708 
     - providerId
2709 
     - destination_city_reached_orders
2710 
    """
2711 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2712 
    self.recv_markOrdersAsDestinationCityReached()
2713 
 
2714 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2715 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2716 
    args = markOrdersAsDestinationCityReached_args()
2717 
    args.providerId = providerId
2718 
    args.destination_city_reached_orders = destination_city_reached_orders
2719 
    args.write(self._oprot)
2720 
    self._oprot.writeMessageEnd()
2721 
    self._oprot.trans.flush()
2722 
 
2723 
  def recv_markOrdersAsDestinationCityReached(self, ):
2724 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2725 
    if mtype == TMessageType.EXCEPTION:
2726 
      x = TApplicationException()
2727 
      x.read(self._iprot)
2728 
      self._iprot.readMessageEnd()
2729 
      raise x
2730 
    result = markOrdersAsDestinationCityReached_result()
2731 
    result.read(self._iprot)
2732 
    self._iprot.readMessageEnd()
2733 
    if result.ex is not None:
2734 
      raise result.ex
2735 
    return
2736 
 
2737 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2738 
    """
2739 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
2740 
 
2741 
    Parameters:
2742 
     - providerId
2743 
     - first_atdl_orders
2744 
    """
2745 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
2746 
    self.recv_markOrdersAsFirstDeliveryAttempted()
2747 
 
2748 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2749 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
2750 
    args = markOrdersAsFirstDeliveryAttempted_args()
2751 
    args.providerId = providerId
2752 
    args.first_atdl_orders = first_atdl_orders
2753 
    args.write(self._oprot)
2754 
    self._oprot.writeMessageEnd()
2755 
    self._oprot.trans.flush()
2756 
 
2757 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
2758 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2759 
    if mtype == TMessageType.EXCEPTION:
2760 
      x = TApplicationException()
2761 
      x.read(self._iprot)
2762 
      self._iprot.readMessageEnd()
2763 
      raise x
2764 
    result = markOrdersAsFirstDeliveryAttempted_result()
2765 
    result.read(self._iprot)
2766 
    self._iprot.readMessageEnd()
2767 
    if result.ex is not None:
2768 
      raise result.ex
2769 
    return
2770 
 
3064 chandransh 2771 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2772 
    """
3064 chandransh 2773 
    Returns the list of orders whose delivery time has passed but have not been
2774 
    delivered yet for the given provider and warehouse. To get a complete list of
2775 
    undelivered orders, pass them as -1.
2776 
    Returns an empty list if no such orders exist.
3431 rajveer 2777 
 
1886 ankur.sing 2778 
    Parameters:
3064 chandransh 2779 
     - providerId
2780 
     - warehouseId
1886 ankur.sing 2781 
    """
3064 chandransh 2782 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2783 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2784 
 
3064 chandransh 2785 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2786 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2787 
    args = getUndeliveredOrders_args()
2788 
    args.providerId = providerId
2789 
    args.warehouseId = warehouseId
1886 ankur.sing 2790 
    args.write(self._oprot)
2791 
    self._oprot.writeMessageEnd()
2792 
    self._oprot.trans.flush()
2793 
 
3064 chandransh 2794 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2796 
    if mtype == TMessageType.EXCEPTION:
2797 
      x = TApplicationException()
2798 
      x.read(self._iprot)
2799 
      self._iprot.readMessageEnd()
2800 
      raise x
3064 chandransh 2801 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2802 
    result.read(self._iprot)
2803 
    self._iprot.readMessageEnd()
3431 rajveer 2804 
    if result.success is not None:
1886 ankur.sing 2805 
      return result.success
3064 chandransh 2806 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2807 
 
4783 phani.kuma 2808 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2809 
    """
2810 
    Returns the list of orders whose expected delivery date has passed but have not been
2811 
    delivered yet.
2812 
    Returns an empty list if no such orders exist.
2813 
    """
2814 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2815 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2816 
 
2817 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2818 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2819 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2820 
    args.write(self._oprot)
2821 
    self._oprot.writeMessageEnd()
2822 
    self._oprot.trans.flush()
2823 
 
2824 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2825 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2826 
    if mtype == TMessageType.EXCEPTION:
2827 
      x = TApplicationException()
2828 
      x.read(self._iprot)
2829 
      self._iprot.readMessageEnd()
2830 
      raise x
2831 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2832 
    result.read(self._iprot)
2833 
    self._iprot.readMessageEnd()
2834 
    if result.success is not None:
2835 
      return result.success
2836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2837 
 
2536 chandransh 2838 
  def toggleDOAFlag(self, orderId):
2839 
    """
2840 
    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.
2841 
    Returns the final flag status.
2842 
    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 2843 
 
2536 chandransh 2844 
    Parameters:
2845 
     - orderId
2846 
    """
2847 
    self.send_toggleDOAFlag(orderId)
2848 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2849 
 
2536 chandransh 2850 
  def send_toggleDOAFlag(self, orderId):
2851 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2852 
    args = toggleDOAFlag_args()
2853 
    args.orderId = orderId
2854 
    args.write(self._oprot)
2855 
    self._oprot.writeMessageEnd()
2856 
    self._oprot.trans.flush()
2857 
 
2858 
  def recv_toggleDOAFlag(self, ):
2859 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2860 
    if mtype == TMessageType.EXCEPTION:
2861 
      x = TApplicationException()
2862 
      x.read(self._iprot)
2863 
      self._iprot.readMessageEnd()
2864 
      raise x
2865 
    result = toggleDOAFlag_result()
2866 
    result.read(self._iprot)
2867 
    self._iprot.readMessageEnd()
3431 rajveer 2868 
    if result.success is not None:
2536 chandransh 2869 
      return result.success
3431 rajveer 2870 
    if result.ex is not None:
2536 chandransh 2871 
      raise result.ex
2872 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2873 
 
4712 rajveer 2874 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2875 
    """
2876 
    Parameters:
2877 
     - orderId
2878 
     - deliveryTimestamp
2879 
     - receiver
2880 
    """
2881 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2882 
    self.recv_markOrderAsDelivered()
2883 
 
2884 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2885 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2886 
    args = markOrderAsDelivered_args()
2887 
    args.orderId = orderId
2888 
    args.deliveryTimestamp = deliveryTimestamp
2889 
    args.receiver = receiver
2890 
    args.write(self._oprot)
2891 
    self._oprot.writeMessageEnd()
2892 
    self._oprot.trans.flush()
2893 
 
2894 
  def recv_markOrderAsDelivered(self, ):
2895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2896 
    if mtype == TMessageType.EXCEPTION:
2897 
      x = TApplicationException()
2898 
      x.read(self._iprot)
2899 
      self._iprot.readMessageEnd()
2900 
      raise x
2901 
    result = markOrderAsDelivered_result()
2902 
    result.read(self._iprot)
2903 
    self._iprot.readMessageEnd()
2904 
    if result.ex is not None:
2905 
      raise result.ex
2906 
    return
2907 
 
4454 rajveer 2908 
  def markOrderDoaRequestReceived(self, orderId):
2909 
    """
2910 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2911 
 
2912 
    Parameters:
2913 
     - orderId
2914 
    """
2915 
    self.send_markOrderDoaRequestReceived(orderId)
2916 
    return self.recv_markOrderDoaRequestReceived()
2917 
 
2918 
  def send_markOrderDoaRequestReceived(self, orderId):
2919 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2920 
    args = markOrderDoaRequestReceived_args()
2921 
    args.orderId = orderId
2922 
    args.write(self._oprot)
2923 
    self._oprot.writeMessageEnd()
2924 
    self._oprot.trans.flush()
2925 
 
2926 
  def recv_markOrderDoaRequestReceived(self, ):
2927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2928 
    if mtype == TMessageType.EXCEPTION:
2929 
      x = TApplicationException()
2930 
      x.read(self._iprot)
2931 
      self._iprot.readMessageEnd()
2932 
      raise x
2933 
    result = markOrderDoaRequestReceived_result()
2934 
    result.read(self._iprot)
2935 
    self._iprot.readMessageEnd()
2936 
    if result.success is not None:
2937 
      return result.success
2938 
    if result.ex is not None:
2939 
      raise result.ex
2940 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2941 
 
2942 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2943 
    """
2944 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2945 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2946 
 
2947 
    Parameters:
2948 
     - orderId
2949 
     - isAuthorized
2950 
    """
2951 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2952 
    return self.recv_markOrderDoaRequestAuthorized()
2953 
 
2954 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2955 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2956 
    args = markOrderDoaRequestAuthorized_args()
2957 
    args.orderId = orderId
2958 
    args.isAuthorized = isAuthorized
2959 
    args.write(self._oprot)
2960 
    self._oprot.writeMessageEnd()
2961 
    self._oprot.trans.flush()
2962 
 
2963 
  def recv_markOrderDoaRequestAuthorized(self, ):
2964 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2965 
    if mtype == TMessageType.EXCEPTION:
2966 
      x = TApplicationException()
2967 
      x.read(self._iprot)
2968 
      self._iprot.readMessageEnd()
2969 
      raise x
2970 
    result = markOrderDoaRequestAuthorized_result()
2971 
    result.read(self._iprot)
2972 
    self._iprot.readMessageEnd()
2973 
    if result.success is not None:
2974 
      return result.success
2975 
    if result.ex is not None:
2976 
      raise result.ex
2977 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2978 
 
4488 rajveer 2979 
  def markOrderReturnRequestReceived(self, orderId):
2980 
    """
2981 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2982 
 
2983 
    Parameters:
2984 
     - orderId
2985 
    """
2986 
    self.send_markOrderReturnRequestReceived(orderId)
2987 
    return self.recv_markOrderReturnRequestReceived()
2988 
 
2989 
  def send_markOrderReturnRequestReceived(self, orderId):
2990 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2991 
    args = markOrderReturnRequestReceived_args()
2992 
    args.orderId = orderId
2993 
    args.write(self._oprot)
2994 
    self._oprot.writeMessageEnd()
2995 
    self._oprot.trans.flush()
2996 
 
2997 
  def recv_markOrderReturnRequestReceived(self, ):
2998 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2999 
    if mtype == TMessageType.EXCEPTION:
3000 
      x = TApplicationException()
3001 
      x.read(self._iprot)
3002 
      self._iprot.readMessageEnd()
3003 
      raise x
3004 
    result = markOrderReturnRequestReceived_result()
3005 
    result.read(self._iprot)
3006 
    self._iprot.readMessageEnd()
3007 
    if result.success is not None:
3008 
      return result.success
3009 
    if result.ex is not None:
3010 
      raise result.ex
3011 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3012 
 
3013 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3014 
    """
3015 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3016 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3017 
 
3018 
    Parameters:
3019 
     - orderId
3020 
     - isAuthorized
3021 
    """
3022 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3023 
    return self.recv_markOrderReturnRequestAuthorized()
3024 
 
3025 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3026 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3027 
    args = markOrderReturnRequestAuthorized_args()
3028 
    args.orderId = orderId
3029 
    args.isAuthorized = isAuthorized
3030 
    args.write(self._oprot)
3031 
    self._oprot.writeMessageEnd()
3032 
    self._oprot.trans.flush()
3033 
 
3034 
  def recv_markOrderReturnRequestAuthorized(self, ):
3035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3036 
    if mtype == TMessageType.EXCEPTION:
3037 
      x = TApplicationException()
3038 
      x.read(self._iprot)
3039 
      self._iprot.readMessageEnd()
3040 
      raise x
3041 
    result = markOrderReturnRequestAuthorized_result()
3042 
    result.read(self._iprot)
3043 
    self._iprot.readMessageEnd()
3044 
    if result.success is not None:
3045 
      return result.success
3046 
    if result.ex is not None:
3047 
      raise result.ex
3048 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3049 
 
4579 rajveer 3050 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3051 
    """
3052 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3053 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3054 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3055 
    For any other status, it returns false.
3056 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3057 
 
2536 chandransh 3058 
    Parameters:
3059 
     - orderId
4579 rajveer 3060 
     - providerId
2536 chandransh 3061 
    """
4579 rajveer 3062 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3063 
    return self.recv_requestPickupNumber()
3064 
 
4579 rajveer 3065 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3066 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3067 
    args = requestPickupNumber_args()
3068 
    args.orderId = orderId
4579 rajveer 3069 
    args.providerId = providerId
2536 chandransh 3070 
    args.write(self._oprot)
3071 
    self._oprot.writeMessageEnd()
3072 
    self._oprot.trans.flush()
3073 
 
3074 
  def recv_requestPickupNumber(self, ):
3075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3076 
    if mtype == TMessageType.EXCEPTION:
3077 
      x = TApplicationException()
3078 
      x.read(self._iprot)
3079 
      self._iprot.readMessageEnd()
3080 
      raise x
3081 
    result = requestPickupNumber_result()
3082 
    result.read(self._iprot)
3083 
    self._iprot.readMessageEnd()
3431 rajveer 3084 
    if result.success is not None:
2536 chandransh 3085 
      return result.success
3431 rajveer 3086 
    if result.ex is not None:
2536 chandransh 3087 
      raise result.ex
3088 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3089 
 
4602 rajveer 3090 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3091 
    """
4452 rajveer 3092 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3093 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3094 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3095 
    	3. Returns true
2591 chandransh 3096 
    If the order is in any other status, it returns false.
2536 chandransh 3097 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3098 
 
2536 chandransh 3099 
    Parameters:
3100 
     - orderId
3101 
     - pickupNumber
4602 rajveer 3102 
     - providerId
2536 chandransh 3103 
    """
4602 rajveer 3104 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3105 
    return self.recv_authorizePickup()
3106 
 
4602 rajveer 3107 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3108 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3109 
    args = authorizePickup_args()
3110 
    args.orderId = orderId
3111 
    args.pickupNumber = pickupNumber
4602 rajveer 3112 
    args.providerId = providerId
2536 chandransh 3113 
    args.write(self._oprot)
3114 
    self._oprot.writeMessageEnd()
3115 
    self._oprot.trans.flush()
3116 
 
3117 
  def recv_authorizePickup(self, ):
3118 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3119 
    if mtype == TMessageType.EXCEPTION:
3120 
      x = TApplicationException()
3121 
      x.read(self._iprot)
3122 
      self._iprot.readMessageEnd()
3123 
      raise x
3124 
    result = authorizePickup_result()
3125 
    result.read(self._iprot)
3126 
    self._iprot.readMessageEnd()
3431 rajveer 3127 
    if result.success is not None:
2536 chandransh 3128 
      return result.success
3431 rajveer 3129 
    if result.ex is not None:
2536 chandransh 3130 
      raise result.ex
3131 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3132 
 
2764 chandransh 3133 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3134 
    """
3135 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3136 
 
2764 chandransh 3137 
    Parameters:
3138 
     - providerId
3139 
     - pickupDetails
3140 
    """
3141 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3142 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3143 
 
3144 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3145 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3146 
    args = markDoasAsPickedUp_args()
3147 
    args.providerId = providerId
3148 
    args.pickupDetails = pickupDetails
3149 
    args.write(self._oprot)
3150 
    self._oprot.writeMessageEnd()
3151 
    self._oprot.trans.flush()
3152 
 
3153 
  def recv_markDoasAsPickedUp(self, ):
3154 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3155 
    if mtype == TMessageType.EXCEPTION:
3156 
      x = TApplicationException()
3157 
      x.read(self._iprot)
3158 
      self._iprot.readMessageEnd()
3159 
      raise x
3160 
    result = markDoasAsPickedUp_result()
3161 
    result.read(self._iprot)
3162 
    self._iprot.readMessageEnd()
4910 phani.kuma 3163 
    return
3164 
 
3165 
  def getDoasNotPickedUp(self, providerId):
3166 
    """
3167 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3168 
 
3169 
    Parameters:
3170 
     - providerId
3171 
    """
3172 
    self.send_getDoasNotPickedUp(providerId)
3173 
    return self.recv_getDoasNotPickedUp()
3174 
 
3175 
  def send_getDoasNotPickedUp(self, providerId):
3176 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3177 
    args = getDoasNotPickedUp_args()
3178 
    args.providerId = providerId
3179 
    args.write(self._oprot)
3180 
    self._oprot.writeMessageEnd()
3181 
    self._oprot.trans.flush()
3182 
 
3183 
  def recv_getDoasNotPickedUp(self, ):
3184 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3185 
    if mtype == TMessageType.EXCEPTION:
3186 
      x = TApplicationException()
3187 
      x.read(self._iprot)
3188 
      self._iprot.readMessageEnd()
3189 
      raise x
3190 
    result = getDoasNotPickedUp_result()
3191 
    result.read(self._iprot)
3192 
    self._iprot.readMessageEnd()
3431 rajveer 3193 
    if result.success is not None:
2764 chandransh 3194 
      return result.success
4910 phani.kuma 3195 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3196 
 
4741 phani.kuma 3197 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3198 
    """
3199 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3200 
 
3201 
    Parameters:
3202 
     - providerId
3203 
     - pickupDetails
3204 
    """
3205 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3206 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3207 
 
3208 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3209 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3210 
    args = markReturnOrdersAsPickedUp_args()
3211 
    args.providerId = providerId
3212 
    args.pickupDetails = pickupDetails
3213 
    args.write(self._oprot)
3214 
    self._oprot.writeMessageEnd()
3215 
    self._oprot.trans.flush()
3216 
 
3217 
  def recv_markReturnOrdersAsPickedUp(self, ):
3218 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3219 
    if mtype == TMessageType.EXCEPTION:
3220 
      x = TApplicationException()
3221 
      x.read(self._iprot)
3222 
      self._iprot.readMessageEnd()
3223 
      raise x
3224 
    result = markReturnOrdersAsPickedUp_result()
3225 
    result.read(self._iprot)
3226 
    self._iprot.readMessageEnd()
4910 phani.kuma 3227 
    return
3228 
 
3229 
  def getReturnOrdersNotPickedUp(self, providerId):
3230 
    """
3231 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3232 
 
3233 
    Parameters:
3234 
     - providerId
3235 
    """
3236 
    self.send_getReturnOrdersNotPickedUp(providerId)
3237 
    return self.recv_getReturnOrdersNotPickedUp()
3238 
 
3239 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3240 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3241 
    args = getReturnOrdersNotPickedUp_args()
3242 
    args.providerId = providerId
3243 
    args.write(self._oprot)
3244 
    self._oprot.writeMessageEnd()
3245 
    self._oprot.trans.flush()
3246 
 
3247 
  def recv_getReturnOrdersNotPickedUp(self, ):
3248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3249 
    if mtype == TMessageType.EXCEPTION:
3250 
      x = TApplicationException()
3251 
      x.read(self._iprot)
3252 
      self._iprot.readMessageEnd()
3253 
      raise x
3254 
    result = getReturnOrdersNotPickedUp_result()
3255 
    result.read(self._iprot)
3256 
    self._iprot.readMessageEnd()
4741 phani.kuma 3257 
    if result.success is not None:
3258 
      return result.success
4910 phani.kuma 3259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3260 
 
4479 rajveer 3261 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3262 
    """
4452 rajveer 3263 
    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 3264 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3265 
    If the order is in any other state, it returns false.
3266 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3267 
 
2591 chandransh 3268 
    Parameters:
3269 
     - orderId
4479 rajveer 3270 
     - receiveCondition
2591 chandransh 3271 
    """
4479 rajveer 3272 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3273 
    return self.recv_receiveReturn()
2536 chandransh 3274 
 
4479 rajveer 3275 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3276 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3277 
    args = receiveReturn_args()
2591 chandransh 3278 
    args.orderId = orderId
4479 rajveer 3279 
    args.receiveCondition = receiveCondition
2591 chandransh 3280 
    args.write(self._oprot)
3281 
    self._oprot.writeMessageEnd()
3282 
    self._oprot.trans.flush()
3283 
 
2616 chandransh 3284 
  def recv_receiveReturn(self, ):
2591 chandransh 3285 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3286 
    if mtype == TMessageType.EXCEPTION:
3287 
      x = TApplicationException()
3288 
      x.read(self._iprot)
3289 
      self._iprot.readMessageEnd()
3290 
      raise x
2616 chandransh 3291 
    result = receiveReturn_result()
2591 chandransh 3292 
    result.read(self._iprot)
3293 
    self._iprot.readMessageEnd()
3431 rajveer 3294 
    if result.success is not None:
2591 chandransh 3295 
      return result.success
3431 rajveer 3296 
    if result.ex is not None:
2591 chandransh 3297 
      raise result.ex
2616 chandransh 3298 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3299 
 
3300 
  def validateDoa(self, orderId, isValid):
3301 
    """
4452 rajveer 3302 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3303 
    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 3304 
    If the order is in any other state, it returns false.
3305 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3306 
 
2591 chandransh 3307 
    Parameters:
3308 
     - orderId
3309 
     - isValid
3310 
    """
3311 
    self.send_validateDoa(orderId, isValid)
3312 
    return self.recv_validateDoa()
3313 
 
3314 
  def send_validateDoa(self, orderId, isValid):
3315 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3316 
    args = validateDoa_args()
3317 
    args.orderId = orderId
3318 
    args.isValid = isValid
3319 
    args.write(self._oprot)
3320 
    self._oprot.writeMessageEnd()
3321 
    self._oprot.trans.flush()
3322 
 
3323 
  def recv_validateDoa(self, ):
3324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3325 
    if mtype == TMessageType.EXCEPTION:
3326 
      x = TApplicationException()
3327 
      x.read(self._iprot)
3328 
      self._iprot.readMessageEnd()
3329 
      raise x
3330 
    result = validateDoa_result()
3331 
    result.read(self._iprot)
3332 
    self._iprot.readMessageEnd()
3431 rajveer 3333 
    if result.success is not None:
2591 chandransh 3334 
      return result.success
3431 rajveer 3335 
    if result.ex is not None:
2591 chandransh 3336 
      raise result.ex
3337 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3338 
 
4495 rajveer 3339 
  def validateReturnProduct(self, orderId, isUsable):
3340 
    """
3341 
    Parameters:
3342 
     - orderId
3343 
     - isUsable
3344 
    """
3345 
    self.send_validateReturnProduct(orderId, isUsable)
3346 
    return self.recv_validateReturnProduct()
3347 
 
3348 
  def send_validateReturnProduct(self, orderId, isUsable):
3349 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3350 
    args = validateReturnProduct_args()
3351 
    args.orderId = orderId
3352 
    args.isUsable = isUsable
3353 
    args.write(self._oprot)
3354 
    self._oprot.writeMessageEnd()
3355 
    self._oprot.trans.flush()
3356 
 
3357 
  def recv_validateReturnProduct(self, ):
3358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3359 
    if mtype == TMessageType.EXCEPTION:
3360 
      x = TApplicationException()
3361 
      x.read(self._iprot)
3362 
      self._iprot.readMessageEnd()
3363 
      raise x
3364 
    result = validateReturnProduct_result()
3365 
    result.read(self._iprot)
3366 
    self._iprot.readMessageEnd()
3367 
    if result.success is not None:
3368 
      return result.success
3369 
    if result.ex is not None:
3370 
      raise result.ex
3371 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3372 
 
2616 chandransh 3373 
  def reshipOrder(self, orderId):
3374 
    """
4484 rajveer 3375 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3376 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3377 
    	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 3378 
 
3379 
    If the order is in DOA_CERT_VALID state, it does the following:
3380 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3381 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3382 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3383 
 
2616 chandransh 3384 
    Returns the id of the newly created order.
3431 rajveer 3385 
 
2616 chandransh 3386 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3387 
 
2616 chandransh 3388 
    Parameters:
3389 
     - orderId
3390 
    """
3391 
    self.send_reshipOrder(orderId)
3392 
    return self.recv_reshipOrder()
2591 chandransh 3393 
 
2616 chandransh 3394 
  def send_reshipOrder(self, orderId):
3395 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3396 
    args = reshipOrder_args()
3397 
    args.orderId = orderId
3398 
    args.write(self._oprot)
3399 
    self._oprot.writeMessageEnd()
3400 
    self._oprot.trans.flush()
3401 
 
3402 
  def recv_reshipOrder(self, ):
3403 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3404 
    if mtype == TMessageType.EXCEPTION:
3405 
      x = TApplicationException()
3406 
      x.read(self._iprot)
3407 
      self._iprot.readMessageEnd()
3408 
      raise x
3409 
    result = reshipOrder_result()
3410 
    result.read(self._iprot)
3411 
    self._iprot.readMessageEnd()
3431 rajveer 3412 
    if result.success is not None:
2616 chandransh 3413 
      return result.success
3431 rajveer 3414 
    if result.ex is not None:
2616 chandransh 3415 
      raise result.ex
3416 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3417 
 
3226 chandransh 3418 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3419 
    """
4484 rajveer 3420 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3421 
    	1. Creates a refund request for batch processing.
3422 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3423 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3424 
 
2616 chandransh 3425 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3426 
    	1. Creates a refund request for batch processing.
3226 chandransh 3427 
    	2. Cancels the reservation of the item in the warehouse.
3428 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3429 
 
3226 chandransh 3430 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3431 
    	1. Cancels the reservation of the item in the warehouse.
3432 
    	2. Marks the current order as CANCELED.
3433 
 
3434 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3435 
 
2616 chandransh 3436 
    Returns True if it is successful, False otherwise.
3431 rajveer 3437 
 
2616 chandransh 3438 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3439 
 
2616 chandransh 3440 
    Parameters:
3441 
     - orderId
3226 chandransh 3442 
     - refundedBy
3443 
     - reason
2616 chandransh 3444 
    """
3226 chandransh 3445 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3446 
    return self.recv_refundOrder()
3447 
 
3226 chandransh 3448 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3449 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3450 
    args = refundOrder_args()
3451 
    args.orderId = orderId
3226 chandransh 3452 
    args.refundedBy = refundedBy
3453 
    args.reason = reason
2616 chandransh 3454 
    args.write(self._oprot)
3455 
    self._oprot.writeMessageEnd()
3456 
    self._oprot.trans.flush()
3457 
 
3458 
  def recv_refundOrder(self, ):
3459 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3460 
    if mtype == TMessageType.EXCEPTION:
3461 
      x = TApplicationException()
3462 
      x.read(self._iprot)
3463 
      self._iprot.readMessageEnd()
3464 
      raise x
3465 
    result = refundOrder_result()
3466 
    result.read(self._iprot)
3467 
    self._iprot.readMessageEnd()
3431 rajveer 3468 
    if result.success is not None:
2616 chandransh 3469 
      return result.success
3431 rajveer 3470 
    if result.ex is not None:
2616 chandransh 3471 
      raise result.ex
3472 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3473 
 
2690 chandransh 3474 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3475 
    """
3476 
    Get all return orders created between the from and to dates for the given warehouse.
3477 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3478 
 
2690 chandransh 3479 
    Parameters:
3480 
     - warehouseId
3481 
     - fromDate
3482 
     - toDate
3483 
    """
3484 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3485 
    return self.recv_getReturnOrders()
2616 chandransh 3486 
 
2690 chandransh 3487 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3488 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3489 
    args = getReturnOrders_args()
3490 
    args.warehouseId = warehouseId
3491 
    args.fromDate = fromDate
3492 
    args.toDate = toDate
3493 
    args.write(self._oprot)
3494 
    self._oprot.writeMessageEnd()
3495 
    self._oprot.trans.flush()
3496 
 
3497 
  def recv_getReturnOrders(self, ):
3498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3499 
    if mtype == TMessageType.EXCEPTION:
3500 
      x = TApplicationException()
3501 
      x.read(self._iprot)
3502 
      self._iprot.readMessageEnd()
3503 
      raise x
3504 
    result = getReturnOrders_result()
3505 
    result.read(self._iprot)
3506 
    self._iprot.readMessageEnd()
3431 rajveer 3507 
    if result.success is not None:
2690 chandransh 3508 
      return result.success
3509 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3510 
 
2700 chandransh 3511 
  def getReturnOrder(self, id):
3512 
    """
3513 
    Returns the ReturnOrder corresponding to the given id.
3514 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3515 
 
2700 chandransh 3516 
    Parameters:
3517 
     - id
3518 
    """
3519 
    self.send_getReturnOrder(id)
3520 
    return self.recv_getReturnOrder()
3521 
 
3522 
  def send_getReturnOrder(self, id):
3523 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3524 
    args = getReturnOrder_args()
3525 
    args.id = id
3526 
    args.write(self._oprot)
3527 
    self._oprot.writeMessageEnd()
3528 
    self._oprot.trans.flush()
3529 
 
3530 
  def recv_getReturnOrder(self, ):
3531 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3532 
    if mtype == TMessageType.EXCEPTION:
3533 
      x = TApplicationException()
3534 
      x.read(self._iprot)
3535 
      self._iprot.readMessageEnd()
3536 
      raise x
3537 
    result = getReturnOrder_result()
3538 
    result.read(self._iprot)
3539 
    self._iprot.readMessageEnd()
3431 rajveer 3540 
    if result.success is not None:
2700 chandransh 3541 
      return result.success
3431 rajveer 3542 
    if result.ex is not None:
2700 chandransh 3543 
      raise result.ex
3544 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3545 
 
2690 chandransh 3546 
  def processReturn(self, returnOrderId):
3547 
    """
3548 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3549 
 
2690 chandransh 3550 
    Parameters:
3551 
     - returnOrderId
3552 
    """
3553 
    self.send_processReturn(returnOrderId)
3554 
    self.recv_processReturn()
3555 
 
3556 
  def send_processReturn(self, returnOrderId):
3557 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3558 
    args = processReturn_args()
3559 
    args.returnOrderId = returnOrderId
3560 
    args.write(self._oprot)
3561 
    self._oprot.writeMessageEnd()
3562 
    self._oprot.trans.flush()
3563 
 
3564 
  def recv_processReturn(self, ):
3565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3566 
    if mtype == TMessageType.EXCEPTION:
3567 
      x = TApplicationException()
3568 
      x.read(self._iprot)
3569 
      self._iprot.readMessageEnd()
3570 
      raise x
3571 
    result = processReturn_result()
3572 
    result.read(self._iprot)
3573 
    self._iprot.readMessageEnd()
3431 rajveer 3574 
    if result.ex is not None:
2690 chandransh 3575 
      raise result.ex
3576 
    return
3577 
 
3451 chandransh 3578 
  def updateWeight(self, orderId, weight):
3579 
    """
3580 
    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 3581 
 
3451 chandransh 3582 
    Parameters:
3583 
     - orderId
3584 
     - weight
3585 
    """
3586 
    self.send_updateWeight(orderId, weight)
3587 
    return self.recv_updateWeight()
3588 
 
3589 
  def send_updateWeight(self, orderId, weight):
3590 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3591 
    args = updateWeight_args()
3592 
    args.orderId = orderId
3593 
    args.weight = weight
3594 
    args.write(self._oprot)
3595 
    self._oprot.writeMessageEnd()
3596 
    self._oprot.trans.flush()
3597 
 
3598 
  def recv_updateWeight(self, ):
3599 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3600 
    if mtype == TMessageType.EXCEPTION:
3601 
      x = TApplicationException()
3602 
      x.read(self._iprot)
3603 
      self._iprot.readMessageEnd()
3604 
      raise x
3605 
    result = updateWeight_result()
3606 
    result.read(self._iprot)
3607 
    self._iprot.readMessageEnd()
3608 
    if result.success is not None:
3609 
      return result.success
3610 
    if result.ex is not None:
3611 
      raise result.ex
3612 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3613 
 
3469 chandransh 3614 
  def changeItem(self, orderId, itemId):
3615 
    """
3616 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3617 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3618 
 
3469 chandransh 3619 
    Parameters:
3620 
     - orderId
3621 
     - itemId
3622 
    """
3623 
    self.send_changeItem(orderId, itemId)
3624 
    return self.recv_changeItem()
3625 
 
3626 
  def send_changeItem(self, orderId, itemId):
3627 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3628 
    args = changeItem_args()
3629 
    args.orderId = orderId
3630 
    args.itemId = itemId
3631 
    args.write(self._oprot)
3632 
    self._oprot.writeMessageEnd()
3633 
    self._oprot.trans.flush()
3634 
 
3635 
  def recv_changeItem(self, ):
3636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3637 
    if mtype == TMessageType.EXCEPTION:
3638 
      x = TApplicationException()
3639 
      x.read(self._iprot)
3640 
      self._iprot.readMessageEnd()
3641 
      raise x
3642 
    result = changeItem_result()
3643 
    result.read(self._iprot)
3644 
    self._iprot.readMessageEnd()
3645 
    if result.success is not None:
3646 
      return result.success
3647 
    if result.ex is not None:
3648 
      raise result.ex
3649 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3650 
 
3651 
  def shiftToWarehouse(self, orderId, warehouseId):
3652 
    """
3653 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3654 
 
3655 
    Parameters:
3656 
     - orderId
3657 
     - warehouseId
3658 
    """
3659 
    self.send_shiftToWarehouse(orderId, warehouseId)
3660 
    return self.recv_shiftToWarehouse()
3661 
 
3662 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3663 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3664 
    args = shiftToWarehouse_args()
3665 
    args.orderId = orderId
3666 
    args.warehouseId = warehouseId
3667 
    args.write(self._oprot)
3668 
    self._oprot.writeMessageEnd()
3669 
    self._oprot.trans.flush()
3670 
 
3671 
  def recv_shiftToWarehouse(self, ):
3672 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3673 
    if mtype == TMessageType.EXCEPTION:
3674 
      x = TApplicationException()
3675 
      x.read(self._iprot)
3676 
      self._iprot.readMessageEnd()
3677 
      raise x
3678 
    result = shiftToWarehouse_result()
3679 
    result.read(self._iprot)
3680 
    self._iprot.readMessageEnd()
3681 
    if result.success is not None:
3682 
      return result.success
3683 
    if result.ex is not None:
3684 
      raise result.ex
3685 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3686 
 
4647 rajveer 3687 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3688 
    """
3689 
    Adds the given delay reason to the given order.
3986 chandransh 3690 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3691 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3692 
 
3553 chandransh 3693 
    Parameters:
3694 
     - orderId
3695 
     - delayReason
3986 chandransh 3696 
     - furtherDelay
4647 rajveer 3697 
     - delayReasonText
3553 chandransh 3698 
    """
4647 rajveer 3699 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3700 
    return self.recv_addDelayReason()
3701 
 
4647 rajveer 3702 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3703 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3704 
    args = addDelayReason_args()
3705 
    args.orderId = orderId
3706 
    args.delayReason = delayReason
3986 chandransh 3707 
    args.furtherDelay = furtherDelay
4647 rajveer 3708 
    args.delayReasonText = delayReasonText
3553 chandransh 3709 
    args.write(self._oprot)
3710 
    self._oprot.writeMessageEnd()
3711 
    self._oprot.trans.flush()
3712 
 
3713 
  def recv_addDelayReason(self, ):
3714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3715 
    if mtype == TMessageType.EXCEPTION:
3716 
      x = TApplicationException()
3717 
      x.read(self._iprot)
3718 
      self._iprot.readMessageEnd()
3719 
      raise x
3720 
    result = addDelayReason_result()
3721 
    result.read(self._iprot)
3722 
    self._iprot.readMessageEnd()
3723 
    if result.success is not None:
3724 
      return result.success
3725 
    if result.ex is not None:
3726 
      raise result.ex
3727 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3728 
 
3956 chandransh 3729 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3730 
    """
3731 
    Marks the COD orders with given AWB nos. as having been processed.
3732 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3733 
 
3956 chandransh 3734 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3735 
    1. There is no order corresponding to an AWB number.
3736 
    2. The captured amount for a payment exceeds the total payment.
3737 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3738 
 
3739 
    Parameters:
3740 
     - collectedAmountMap
3741 
     - xferBy
3742 
     - xferTxnId
3743 
     - xferDate
3744 
    """
3745 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3746 
    return self.recv_reconcileCodCollection()
3747 
 
3748 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3749 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3750 
    args = reconcileCodCollection_args()
3751 
    args.collectedAmountMap = collectedAmountMap
3752 
    args.xferBy = xferBy
3753 
    args.xferTxnId = xferTxnId
3754 
    args.xferDate = xferDate
3755 
    args.write(self._oprot)
3756 
    self._oprot.writeMessageEnd()
3757 
    self._oprot.trans.flush()
3758 
 
3759 
  def recv_reconcileCodCollection(self, ):
3760 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3761 
    if mtype == TMessageType.EXCEPTION:
3762 
      x = TApplicationException()
3763 
      x.read(self._iprot)
3764 
      self._iprot.readMessageEnd()
3765 
      raise x
3766 
    result = reconcileCodCollection_result()
3767 
    result.read(self._iprot)
3768 
    self._iprot.readMessageEnd()
3769 
    if result.success is not None:
3770 
      return result.success
3771 
    if result.ex is not None:
3772 
      raise result.ex
3773 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3774 
 
4008 mandeep.dh 3775 
  def getTransactionsRequiringExtraProcessing(self, category):
3776 
    """
4065 mandeep.dh 3777 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3778 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3779 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3780 
 
4008 mandeep.dh 3781 
    Parameters:
3782 
     - category
3783 
    """
3784 
    self.send_getTransactionsRequiringExtraProcessing(category)
3785 
    return self.recv_getTransactionsRequiringExtraProcessing()
3786 
 
3787 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3788 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3789 
    args = getTransactionsRequiringExtraProcessing_args()
3790 
    args.category = category
3791 
    args.write(self._oprot)
3792 
    self._oprot.writeMessageEnd()
3793 
    self._oprot.trans.flush()
3794 
 
3795 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3797 
    if mtype == TMessageType.EXCEPTION:
3798 
      x = TApplicationException()
3799 
      x.read(self._iprot)
3800 
      self._iprot.readMessageEnd()
3801 
      raise x
3802 
    result = getTransactionsRequiringExtraProcessing_result()
3803 
    result.read(self._iprot)
3804 
    self._iprot.readMessageEnd()
3805 
    if result.success is not None:
3806 
      return result.success
3807 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3808 
 
3809 
  def markTransactionAsProcessed(self, transactionId, category):
3810 
    """
3811 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3812 
    It essentially deletes the transaction id record for a particular
3813 
    processing type category (if present) from DB.
3814 
    This is currently used by CRM application.
4008 mandeep.dh 3815 
 
3816 
    Parameters:
3817 
     - transactionId
3818 
     - category
3819 
    """
3820 
    self.send_markTransactionAsProcessed(transactionId, category)
3821 
    self.recv_markTransactionAsProcessed()
3822 
 
3823 
  def send_markTransactionAsProcessed(self, transactionId, category):
3824 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3825 
    args = markTransactionAsProcessed_args()
3826 
    args.transactionId = transactionId
3827 
    args.category = category
3828 
    args.write(self._oprot)
3829 
    self._oprot.writeMessageEnd()
3830 
    self._oprot.trans.flush()
3831 
 
3832 
  def recv_markTransactionAsProcessed(self, ):
3833 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3834 
    if mtype == TMessageType.EXCEPTION:
3835 
      x = TApplicationException()
3836 
      x.read(self._iprot)
3837 
      self._iprot.readMessageEnd()
3838 
      raise x
3839 
    result = markTransactionAsProcessed_result()
3840 
    result.read(self._iprot)
3841 
    self._iprot.readMessageEnd()
3842 
    return
3843 
 
4018 chandransh 3844 
  def getItemWiseRiskyOrdersCount(self, ):
3845 
    """
3846 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3847 
    is defined as one whose shipping date is about to expire.
3848 
    """
3849 
    self.send_getItemWiseRiskyOrdersCount()
3850 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3851 
 
4018 chandransh 3852 
  def send_getItemWiseRiskyOrdersCount(self, ):
3853 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3854 
    args = getItemWiseRiskyOrdersCount_args()
3855 
    args.write(self._oprot)
3856 
    self._oprot.writeMessageEnd()
3857 
    self._oprot.trans.flush()
3858 
 
3859 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3860 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3861 
    if mtype == TMessageType.EXCEPTION:
3862 
      x = TApplicationException()
3863 
      x.read(self._iprot)
3864 
      self._iprot.readMessageEnd()
3865 
      raise x
3866 
    result = getItemWiseRiskyOrdersCount_result()
3867 
    result.read(self._iprot)
3868 
    self._iprot.readMessageEnd()
3869 
    if result.success is not None:
3870 
      return result.success
3871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3872 
 
4295 varun.gupt 3873 
  def getOrdersForItemIds(self, itemIds):
3874 
    """
3875 
    Returns a list of all orders which have items with given id
3876 
 
3877 
    Parameters:
3878 
     - itemIds
3879 
    """
3880 
    self.send_getOrdersForItemIds(itemIds)
3881 
    return self.recv_getOrdersForItemIds()
3882 
 
3883 
  def send_getOrdersForItemIds(self, itemIds):
3884 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3885 
    args = getOrdersForItemIds_args()
3886 
    args.itemIds = itemIds
3887 
    args.write(self._oprot)
3888 
    self._oprot.writeMessageEnd()
3889 
    self._oprot.trans.flush()
3890 
 
3891 
  def recv_getOrdersForItemIds(self, ):
3892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3893 
    if mtype == TMessageType.EXCEPTION:
3894 
      x = TApplicationException()
3895 
      x.read(self._iprot)
3896 
      self._iprot.readMessageEnd()
3897 
      raise x
3898 
    result = getOrdersForItemIds_result()
3899 
    result.read(self._iprot)
3900 
    self._iprot.readMessageEnd()
3901 
    if result.success is not None:
3902 
      return result.success
3903 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3904 
 
4247 rajveer 3905 
  def markOrderCancellationRequestReceived(self, orderId):
3906 
    """
3907 
    Mark order as cancellation request received. If customer sends request of cancellation of
3908 
    a particular order, this method will be called. It will just change status of the order
3909 
    depending on its current status. It also records the previous status, so that we can move
3910 
    back to that status if cancellation request is denied.
4018 chandransh 3911 
 
4247 rajveer 3912 
    Parameters:
3913 
     - orderId
3914 
    """
3915 
    self.send_markOrderCancellationRequestReceived(orderId)
3916 
    self.recv_markOrderCancellationRequestReceived()
3917 
 
3918 
  def send_markOrderCancellationRequestReceived(self, orderId):
3919 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3920 
    args = markOrderCancellationRequestReceived_args()
3921 
    args.orderId = orderId
3922 
    args.write(self._oprot)
3923 
    self._oprot.writeMessageEnd()
3924 
    self._oprot.trans.flush()
3925 
 
3926 
  def recv_markOrderCancellationRequestReceived(self, ):
3927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3928 
    if mtype == TMessageType.EXCEPTION:
3929 
      x = TApplicationException()
3930 
      x.read(self._iprot)
3931 
      self._iprot.readMessageEnd()
3932 
      raise x
3933 
    result = markOrderCancellationRequestReceived_result()
3934 
    result.read(self._iprot)
3935 
    self._iprot.readMessageEnd()
3936 
    if result.ex is not None:
3937 
      raise result.ex
3938 
    return
3939 
 
3940 
  def markOrderCancellationRequestConfirmed(self, orderId):
3941 
    """
3942 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3943 
    cancellation request confirmed. After this OM will be able to cancel the order.
3944 
 
3945 
    Parameters:
3946 
     - orderId
3947 
    """
3948 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3949 
    self.recv_markOrderCancellationRequestConfirmed()
3950 
 
3951 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3952 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3953 
    args = markOrderCancellationRequestConfirmed_args()
3954 
    args.orderId = orderId
3955 
    args.write(self._oprot)
3956 
    self._oprot.writeMessageEnd()
3957 
    self._oprot.trans.flush()
3958 
 
3959 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3960 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3961 
    if mtype == TMessageType.EXCEPTION:
3962 
      x = TApplicationException()
3963 
      x.read(self._iprot)
3964 
      self._iprot.readMessageEnd()
3965 
      raise x
3966 
    result = markOrderCancellationRequestConfirmed_result()
3967 
    result.read(self._iprot)
3968 
    self._iprot.readMessageEnd()
3969 
    if result.ex is not None:
3970 
      raise result.ex
3971 
    return
3972 
 
3973 
  def markOrderCancellationRequestDenied(self, orderId):
3974 
    """
3975 
    If we decide to not to cancel order, we will move the order ro previous status.
3976 
 
3977 
    Parameters:
3978 
     - orderId
3979 
    """
3980 
    self.send_markOrderCancellationRequestDenied(orderId)
3981 
    self.recv_markOrderCancellationRequestDenied()
3982 
 
3983 
  def send_markOrderCancellationRequestDenied(self, orderId):
3984 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3985 
    args = markOrderCancellationRequestDenied_args()
3986 
    args.orderId = orderId
3987 
    args.write(self._oprot)
3988 
    self._oprot.writeMessageEnd()
3989 
    self._oprot.trans.flush()
3990 
 
3991 
  def recv_markOrderCancellationRequestDenied(self, ):
3992 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3993 
    if mtype == TMessageType.EXCEPTION:
3994 
      x = TApplicationException()
3995 
      x.read(self._iprot)
3996 
      self._iprot.readMessageEnd()
3997 
      raise x
3998 
    result = markOrderCancellationRequestDenied_result()
3999 
    result.read(self._iprot)
4000 
    self._iprot.readMessageEnd()
4001 
    if result.ex is not None:
4002 
      raise result.ex
4003 
    return
4004 
 
4258 rajveer 4005 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4006 
    """
4258 rajveer 4007 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4008 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4009 
 
4010 
    Parameters:
4258 rajveer 4011 
     - transactionId
4247 rajveer 4012 
    """
4258 rajveer 4013 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4014 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4015 
 
4258 rajveer 4016 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4017 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4018 
    args = markTransactionAsPaymentFlagRemoved_args()
4019 
    args.transactionId = transactionId
4247 rajveer 4020 
    args.write(self._oprot)
4021 
    self._oprot.writeMessageEnd()
4022 
    self._oprot.trans.flush()
4023 
 
4258 rajveer 4024 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4026 
    if mtype == TMessageType.EXCEPTION:
4027 
      x = TApplicationException()
4028 
      x.read(self._iprot)
4029 
      self._iprot.readMessageEnd()
4030 
      raise x
4258 rajveer 4031 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4032 
    result.read(self._iprot)
4033 
    self._iprot.readMessageEnd()
4034 
    if result.ex is not None:
4035 
      raise result.ex
4036 
    return
4037 
 
4259 anupam.sin 4038 
  def refundTransaction(self, transactionId, refundedBy, reason):
4039 
    """
4040 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4041 
    need to be cancelled
4247 rajveer 4042 
 
4259 anupam.sin 4043 
    Parameters:
4044 
     - transactionId
4045 
     - refundedBy
4046 
     - reason
4047 
    """
4048 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4049 
    self.recv_refundTransaction()
4050 
 
4051 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4052 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4053 
    args = refundTransaction_args()
4054 
    args.transactionId = transactionId
4055 
    args.refundedBy = refundedBy
4056 
    args.reason = reason
4057 
    args.write(self._oprot)
4058 
    self._oprot.writeMessageEnd()
4059 
    self._oprot.trans.flush()
4060 
 
4061 
  def recv_refundTransaction(self, ):
4062 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4063 
    if mtype == TMessageType.EXCEPTION:
4064 
      x = TApplicationException()
4065 
      x.read(self._iprot)
4066 
      self._iprot.readMessageEnd()
4067 
      raise x
4068 
    result = refundTransaction_result()
4069 
    result.read(self._iprot)
4070 
    self._iprot.readMessageEnd()
4071 
    if result.ex is not None:
4072 
      raise result.ex
4073 
    return
4074 
 
4324 mandeep.dh 4075 
  def updateShipmentAddress(self, orderId, addressId):
4076 
    """
4077 
    Updates shipment address of an order. Delivery and shipping date estimates
4078 
    etc. are also updated here.
4079 
 
4080 
    Throws TransactionServiceException in case address change is not
4081 
    possible due to certain reasons such as new pincode in address is
4082 
    not serviceable etc.
4083 
 
4084 
    Parameters:
4085 
     - orderId
4086 
     - addressId
4087 
    """
4088 
    self.send_updateShipmentAddress(orderId, addressId)
4089 
    self.recv_updateShipmentAddress()
4090 
 
4091 
  def send_updateShipmentAddress(self, orderId, addressId):
4092 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4093 
    args = updateShipmentAddress_args()
4094 
    args.orderId = orderId
4095 
    args.addressId = addressId
4096 
    args.write(self._oprot)
4097 
    self._oprot.writeMessageEnd()
4098 
    self._oprot.trans.flush()
4099 
 
4100 
  def recv_updateShipmentAddress(self, ):
4101 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4102 
    if mtype == TMessageType.EXCEPTION:
4103 
      x = TApplicationException()
4104 
      x.read(self._iprot)
4105 
      self._iprot.readMessageEnd()
4106 
      raise x
4107 
    result = updateShipmentAddress_result()
4108 
    result.read(self._iprot)
4109 
    self._iprot.readMessageEnd()
4110 
    if result.ex is not None:
4111 
      raise result.ex
4112 
    return
4113 
 
4285 rajveer 4114 
  def acceptOrdersForItemId(self, itemId, inventory):
4115 
    """
4116 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4117 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4118 
 
4285 rajveer 4119 
    Parameters:
4120 
     - itemId
4121 
     - inventory
4122 
    """
4123 
    self.send_acceptOrdersForItemId(itemId, inventory)
4124 
    return self.recv_acceptOrdersForItemId()
4125 
 
4126 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4127 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4128 
    args = acceptOrdersForItemId_args()
4129 
    args.itemId = itemId
4130 
    args.inventory = inventory
4131 
    args.write(self._oprot)
4132 
    self._oprot.writeMessageEnd()
4133 
    self._oprot.trans.flush()
4134 
 
4135 
  def recv_acceptOrdersForItemId(self, ):
4136 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4137 
    if mtype == TMessageType.EXCEPTION:
4138 
      x = TApplicationException()
4139 
      x.read(self._iprot)
4140 
      self._iprot.readMessageEnd()
4141 
      raise x
4142 
    result = acceptOrdersForItemId_result()
4143 
    result.read(self._iprot)
4144 
    self._iprot.readMessageEnd()
4145 
    if result.success is not None:
4146 
      return result.success
4147 
    if result.ex is not None:
4148 
      raise result.ex
4149 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4150 
 
4369 rajveer 4151 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4152 
    """
4153 
    Parameters:
4154 
     - vendorId
4155 
     - itemId
4156 
     - quantity
4157 
     - estimate
4369 rajveer 4158 
     - isReminder
4303 rajveer 4159 
    """
4369 rajveer 4160 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4161 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4162 
 
4369 rajveer 4163 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4164 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4165 
    args = markOrdersAsPORaised_args()
4166 
    args.vendorId = vendorId
4167 
    args.itemId = itemId
4168 
    args.quantity = quantity
4169 
    args.estimate = estimate
4369 rajveer 4170 
    args.isReminder = isReminder
4303 rajveer 4171 
    args.write(self._oprot)
4172 
    self._oprot.writeMessageEnd()
4173 
    self._oprot.trans.flush()
4174 
 
4175 
  def recv_markOrdersAsPORaised(self, ):
4176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4177 
    if mtype == TMessageType.EXCEPTION:
4178 
      x = TApplicationException()
4179 
      x.read(self._iprot)
4180 
      self._iprot.readMessageEnd()
4181 
      raise x
4182 
    result = markOrdersAsPORaised_result()
4183 
    result.read(self._iprot)
4184 
    self._iprot.readMessageEnd()
4185 
    if result.ex is not None:
4186 
      raise result.ex
4187 
    return
4188 
 
4369 rajveer 4189 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4190 
    """
4191 
    Parameters:
4192 
     - vendorId
4193 
     - itemId
4194 
     - quantity
4195 
     - estimate
4369 rajveer 4196 
     - isReminder
4303 rajveer 4197 
    """
4369 rajveer 4198 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4199 
    self.recv_markOrdersAsReversalInitiated()
4200 
 
4369 rajveer 4201 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4202 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4203 
    args = markOrdersAsReversalInitiated_args()
4204 
    args.vendorId = vendorId
4205 
    args.itemId = itemId
4206 
    args.quantity = quantity
4207 
    args.estimate = estimate
4369 rajveer 4208 
    args.isReminder = isReminder
4303 rajveer 4209 
    args.write(self._oprot)
4210 
    self._oprot.writeMessageEnd()
4211 
    self._oprot.trans.flush()
4212 
 
4213 
  def recv_markOrdersAsReversalInitiated(self, ):
4214 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4215 
    if mtype == TMessageType.EXCEPTION:
4216 
      x = TApplicationException()
4217 
      x.read(self._iprot)
4218 
      self._iprot.readMessageEnd()
4219 
      raise x
4220 
    result = markOrdersAsReversalInitiated_result()
4221 
    result.read(self._iprot)
4222 
    self._iprot.readMessageEnd()
4223 
    if result.ex is not None:
4224 
      raise result.ex
4225 
    return
4226 
 
4369 rajveer 4227 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4228 
    """
4229 
    Parameters:
4230 
     - vendorId
4231 
     - itemId
4232 
     - quantity
4233 
     - estimate
4369 rajveer 4234 
     - isReminder
4303 rajveer 4235 
    """
4369 rajveer 4236 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4237 
    self.recv_markOrdersAsNotAvailabke()
4238 
 
4369 rajveer 4239 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4240 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4241 
    args = markOrdersAsNotAvailabke_args()
4242 
    args.vendorId = vendorId
4243 
    args.itemId = itemId
4244 
    args.quantity = quantity
4245 
    args.estimate = estimate
4369 rajveer 4246 
    args.isReminder = isReminder
4303 rajveer 4247 
    args.write(self._oprot)
4248 
    self._oprot.writeMessageEnd()
4249 
    self._oprot.trans.flush()
4250 
 
4251 
  def recv_markOrdersAsNotAvailabke(self, ):
4252 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4253 
    if mtype == TMessageType.EXCEPTION:
4254 
      x = TApplicationException()
4255 
      x.read(self._iprot)
4256 
      self._iprot.readMessageEnd()
4257 
      raise x
4258 
    result = markOrdersAsNotAvailabke_result()
4259 
    result.read(self._iprot)
4260 
    self._iprot.readMessageEnd()
4261 
    if result.ex is not None:
4262 
      raise result.ex
4263 
    return
4264 
 
4369 rajveer 4265 
  def markOrdersAsTimeout(self, vendorId):
4266 
    """
4267 
    Parameters:
4268 
     - vendorId
4269 
    """
4270 
    self.send_markOrdersAsTimeout(vendorId)
4271 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4272 
 
4369 rajveer 4273 
  def send_markOrdersAsTimeout(self, vendorId):
4274 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4275 
    args = markOrdersAsTimeout_args()
4276 
    args.vendorId = vendorId
4277 
    args.write(self._oprot)
4278 
    self._oprot.writeMessageEnd()
4279 
    self._oprot.trans.flush()
4280 
 
4281 
  def recv_markOrdersAsTimeout(self, ):
4282 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4283 
    if mtype == TMessageType.EXCEPTION:
4284 
      x = TApplicationException()
4285 
      x.read(self._iprot)
4286 
      self._iprot.readMessageEnd()
4287 
      raise x
4288 
    result = markOrdersAsTimeout_result()
4289 
    result.read(self._iprot)
4290 
    self._iprot.readMessageEnd()
4291 
    if result.success is not None:
4292 
      return result.success
4293 
    if result.ex is not None:
4294 
      raise result.ex
4295 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4296 
 
4662 rajveer 4297 
  def markOrderAsLostInTransit(self, orderId):
4298 
    """
4299 
    Mark order as LOST_IN_TRANSIT
4300 
 
4301 
    Parameters:
4302 
     - orderId
4303 
    """
4304 
    self.send_markOrderAsLostInTransit(orderId)
4305 
    return self.recv_markOrderAsLostInTransit()
4306 
 
4307 
  def send_markOrderAsLostInTransit(self, orderId):
4308 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4309 
    args = markOrderAsLostInTransit_args()
4310 
    args.orderId = orderId
4311 
    args.write(self._oprot)
4312 
    self._oprot.writeMessageEnd()
4313 
    self._oprot.trans.flush()
4314 
 
4315 
  def recv_markOrderAsLostInTransit(self, ):
4316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4317 
    if mtype == TMessageType.EXCEPTION:
4318 
      x = TApplicationException()
4319 
      x.read(self._iprot)
4320 
      self._iprot.readMessageEnd()
4321 
      raise x
4322 
    result = markOrderAsLostInTransit_result()
4323 
    result.read(self._iprot)
4324 
    self._iprot.readMessageEnd()
4325 
    if result.success is not None:
4326 
      return result.success
4327 
    if result.ex is not None:
4328 
      raise result.ex
4329 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4330 
 
4386 anupam.sin 4331 
  def getOrderForAwb(self, awb):
4332 
    """
4333 
    Returns the order corresponding to an AWB number
4369 rajveer 4334 
 
4386 anupam.sin 4335 
    Parameters:
4336 
     - awb
4337 
    """
4338 
    self.send_getOrderForAwb(awb)
4339 
    return self.recv_getOrderForAwb()
4340 
 
4341 
  def send_getOrderForAwb(self, awb):
4342 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4343 
    args = getOrderForAwb_args()
4344 
    args.awb = awb
4345 
    args.write(self._oprot)
4346 
    self._oprot.writeMessageEnd()
4347 
    self._oprot.trans.flush()
4348 
 
4349 
  def recv_getOrderForAwb(self, ):
4350 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4351 
    if mtype == TMessageType.EXCEPTION:
4352 
      x = TApplicationException()
4353 
      x.read(self._iprot)
4354 
      self._iprot.readMessageEnd()
4355 
      raise x
4356 
    result = getOrderForAwb_result()
4357 
    result.read(self._iprot)
4358 
    self._iprot.readMessageEnd()
4359 
    if result.success is not None:
4360 
      return result.success
4361 
    if result.ex is not None:
4362 
      raise result.ex
4363 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4364 
 
4910 phani.kuma 4365 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4366 
    """
4910 phani.kuma 4367 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4368 
 
4506 phani.kuma 4369 
    Parameters:
4370 
     - logistics_provider_id
4910 phani.kuma 4371 
     - order_status_list
4506 phani.kuma 4372 
    """
4910 phani.kuma 4373 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4374 
    return self.recv_getOrdersForProviderForStatus()
4375 
 
4910 phani.kuma 4376 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4377 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4378 
    args = getOrdersForProviderForStatus_args()
4379 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4380 
    args.order_status_list = order_status_list
4506 phani.kuma 4381 
    args.write(self._oprot)
4382 
    self._oprot.writeMessageEnd()
4383 
    self._oprot.trans.flush()
4384 
 
4385 
  def recv_getOrdersForProviderForStatus(self, ):
4386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4387 
    if mtype == TMessageType.EXCEPTION:
4388 
      x = TApplicationException()
4389 
      x.read(self._iprot)
4390 
      self._iprot.readMessageEnd()
4391 
      raise x
4392 
    result = getOrdersForProviderForStatus_result()
4393 
    result.read(self._iprot)
4394 
    self._iprot.readMessageEnd()
4395 
    if result.success is not None:
4396 
      return result.success
4397 
    if result.ex is not None:
4398 
      raise result.ex
4399 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4400 
 
4600 varun.gupt 4401 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4402 
    """
4403 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4404 
 
4600 varun.gupt 4405 
    Parameters:
4406 
     - vendorId
4407 
     - billingDateFrom
4408 
     - billingDateTo
4409 
    """
4410 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4411 
    return self.recv_getBilledOrdersForVendor()
4412 
 
4413 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4414 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4415 
    args = getBilledOrdersForVendor_args()
4416 
    args.vendorId = vendorId
4417 
    args.billingDateFrom = billingDateFrom
4418 
    args.billingDateTo = billingDateTo
4419 
    args.write(self._oprot)
4420 
    self._oprot.writeMessageEnd()
4421 
    self._oprot.trans.flush()
4422 
 
4423 
  def recv_getBilledOrdersForVendor(self, ):
4424 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4425 
    if mtype == TMessageType.EXCEPTION:
4426 
      x = TApplicationException()
4427 
      x.read(self._iprot)
4428 
      self._iprot.readMessageEnd()
4429 
      raise x
4430 
    result = getBilledOrdersForVendor_result()
4431 
    result.read(self._iprot)
4432 
    self._iprot.readMessageEnd()
4433 
    if result.success is not None:
4434 
      return result.success
4435 
    if result.ex is not None:
4436 
      raise result.ex
4437 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4438 
 
4607 rajveer 4439 
  def getSlippedSippingDateOrders(self, ):
4440 
    self.send_getSlippedSippingDateOrders()
4441 
    return self.recv_getSlippedSippingDateOrders()
4442 
 
4443 
  def send_getSlippedSippingDateOrders(self, ):
4444 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4445 
    args = getSlippedSippingDateOrders_args()
4446 
    args.write(self._oprot)
4447 
    self._oprot.writeMessageEnd()
4448 
    self._oprot.trans.flush()
4449 
 
4450 
  def recv_getSlippedSippingDateOrders(self, ):
4451 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4452 
    if mtype == TMessageType.EXCEPTION:
4453 
      x = TApplicationException()
4454 
      x.read(self._iprot)
4455 
      self._iprot.readMessageEnd()
4456 
      raise x
4457 
    result = getSlippedSippingDateOrders_result()
4458 
    result.read(self._iprot)
4459 
    self._iprot.readMessageEnd()
4460 
    if result.success is not None:
4461 
      return result.success
4462 
    if result.ex is not None:
4463 
      raise result.ex
4464 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4465 
 
4709 rajveer 4466 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4467 
    """
4468 
    Parameters:
4469 
     - cancelDateFrom
4470 
     - cancelDateTo
4471 
    """
4472 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4473 
    return self.recv_getCancelledOrders()
4474 
 
4475 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4476 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4477 
    args = getCancelledOrders_args()
4478 
    args.cancelDateFrom = cancelDateFrom
4479 
    args.cancelDateTo = cancelDateTo
4480 
    args.write(self._oprot)
4481 
    self._oprot.writeMessageEnd()
4482 
    self._oprot.trans.flush()
4483 
 
4484 
  def recv_getCancelledOrders(self, ):
4485 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4486 
    if mtype == TMessageType.EXCEPTION:
4487 
      x = TApplicationException()
4488 
      x.read(self._iprot)
4489 
      self._iprot.readMessageEnd()
4490 
      raise x
4491 
    result = getCancelledOrders_result()
4492 
    result.read(self._iprot)
4493 
    self._iprot.readMessageEnd()
4494 
    if result.success is not None:
4495 
      return result.success
4496 
    if result.ex is not None:
4497 
      raise result.ex
4498 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4499 
 
4600 varun.gupt 4500 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4501 
    """
4502 
    Parameters:
4503 
     - mapAWBAndAmount
4504 
    """
4505 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4506 
    self.recv_saveBluedartSettlements()
4507 
 
4508 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4509 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4510 
    args = saveBluedartSettlements_args()
4511 
    args.mapAWBAndAmount = mapAWBAndAmount
4512 
    args.write(self._oprot)
4513 
    self._oprot.writeMessageEnd()
4514 
    self._oprot.trans.flush()
4515 
 
4516 
  def recv_saveBluedartSettlements(self, ):
4517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4518 
    if mtype == TMessageType.EXCEPTION:
4519 
      x = TApplicationException()
4520 
      x.read(self._iprot)
4521 
      self._iprot.readMessageEnd()
4522 
      raise x
4523 
    result = saveBluedartSettlements_result()
4524 
    result.read(self._iprot)
4525 
    self._iprot.readMessageEnd()
4526 
    if result.ex is not None:
4527 
      raise result.ex
4528 
    return
4529 
 
4905 varun.gupt 4530 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4531 
    """
4532 
    Parameters:
4533 
     - settlementDate
4534 
     - paymentGatewayId
4905 varun.gupt 4535 
     - referenceId
4600 varun.gupt 4536 
     - serviceTax
4537 
     - otherCharges
4538 
     - netCollection
4539 
    """
4905 varun.gupt 4540 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4541 
    self.recv_savePaymentSettlements()
4542 
 
4905 varun.gupt 4543 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4544 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4545 
    args = savePaymentSettlements_args()
4546 
    args.settlementDate = settlementDate
4547 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4548 
    args.referenceId = referenceId
4600 varun.gupt 4549 
    args.serviceTax = serviceTax
4550 
    args.otherCharges = otherCharges
4551 
    args.netCollection = netCollection
4552 
    args.write(self._oprot)
4553 
    self._oprot.writeMessageEnd()
4554 
    self._oprot.trans.flush()
4555 
 
4556 
  def recv_savePaymentSettlements(self, ):
4557 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4558 
    if mtype == TMessageType.EXCEPTION:
4559 
      x = TApplicationException()
4560 
      x.read(self._iprot)
4561 
      self._iprot.readMessageEnd()
4562 
      raise x
4563 
    result = savePaymentSettlements_result()
4564 
    result.read(self._iprot)
4565 
    self._iprot.readMessageEnd()
4566 
    if result.ex is not None:
4567 
      raise result.ex
4568 
    return
4569 
 
4570 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4571 
    """
4572 
    Parameters:
4573 
     - settlementId
4574 
     - settlementDate
4575 
     - transactionDateFrom
4576 
     - transactionDateTo
4577 
     - amount
4578 
    """
4579 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4580 
    self.recv_saveEBSSettlementSummary()
4581 
 
4582 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4583 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4584 
    args = saveEBSSettlementSummary_args()
4585 
    args.settlementId = settlementId
4586 
    args.settlementDate = settlementDate
4587 
    args.transactionDateFrom = transactionDateFrom
4588 
    args.transactionDateTo = transactionDateTo
4589 
    args.amount = amount
4590 
    args.write(self._oprot)
4591 
    self._oprot.writeMessageEnd()
4592 
    self._oprot.trans.flush()
4593 
 
4594 
  def recv_saveEBSSettlementSummary(self, ):
4595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4596 
    if mtype == TMessageType.EXCEPTION:
4597 
      x = TApplicationException()
4598 
      x.read(self._iprot)
4599 
      self._iprot.readMessageEnd()
4600 
      raise x
4601 
    result = saveEBSSettlementSummary_result()
4602 
    result.read(self._iprot)
4603 
    self._iprot.readMessageEnd()
4604 
    if result.ex is not None:
4605 
      raise result.ex
4606 
    return
4607 
 
4608 
  def getSettlementForPaymentId(self, paymentId):
4609 
    """
4610 
    Parameters:
4611 
     - paymentId
4612 
    """
4613 
    self.send_getSettlementForPaymentId(paymentId)
4614 
    return self.recv_getSettlementForPaymentId()
4615 
 
4616 
  def send_getSettlementForPaymentId(self, paymentId):
4617 
    self._oprot.writeMessageBegin('getSettlementForPaymentId', TMessageType.CALL, self._seqid)
4618 
    args = getSettlementForPaymentId_args()
4619 
    args.paymentId = paymentId
4620 
    args.write(self._oprot)
4621 
    self._oprot.writeMessageEnd()
4622 
    self._oprot.trans.flush()
4623 
 
4624 
  def recv_getSettlementForPaymentId(self, ):
4625 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4626 
    if mtype == TMessageType.EXCEPTION:
4627 
      x = TApplicationException()
4628 
      x.read(self._iprot)
4629 
      self._iprot.readMessageEnd()
4630 
      raise x
4631 
    result = getSettlementForPaymentId_result()
4632 
    result.read(self._iprot)
4633 
    self._iprot.readMessageEnd()
4634 
    if result.success is not None:
4635 
      return result.success
4636 
    if result.ex is not None:
4637 
      raise result.ex
4638 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPaymentId failed: unknown result");
4639 
 
4640 
  def getEBSSettlementSummaries(self, ):
4641 
    self.send_getEBSSettlementSummaries()
4642 
    return self.recv_getEBSSettlementSummaries()
4643 
 
4644 
  def send_getEBSSettlementSummaries(self, ):
4645 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4646 
    args = getEBSSettlementSummaries_args()
4647 
    args.write(self._oprot)
4648 
    self._oprot.writeMessageEnd()
4649 
    self._oprot.trans.flush()
4650 
 
4651 
  def recv_getEBSSettlementSummaries(self, ):
4652 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4653 
    if mtype == TMessageType.EXCEPTION:
4654 
      x = TApplicationException()
4655 
      x.read(self._iprot)
4656 
      self._iprot.readMessageEnd()
4657 
      raise x
4658 
    result = getEBSSettlementSummaries_result()
4659 
    result.read(self._iprot)
4660 
    self._iprot.readMessageEnd()
4661 
    if result.success is not None:
4662 
      return result.success
4663 
    if result.ex is not None:
4664 
      raise result.ex
4665 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4666 
 
4667 
  def markEBSSettlementUploaded(self, settlementId):
4668 
    """
4669 
    Parameters:
4670 
     - settlementId
4671 
    """
4672 
    self.send_markEBSSettlementUploaded(settlementId)
4673 
    self.recv_markEBSSettlementUploaded()
4674 
 
4675 
  def send_markEBSSettlementUploaded(self, settlementId):
4676 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4677 
    args = markEBSSettlementUploaded_args()
4678 
    args.settlementId = settlementId
4679 
    args.write(self._oprot)
4680 
    self._oprot.writeMessageEnd()
4681 
    self._oprot.trans.flush()
4682 
 
4683 
  def recv_markEBSSettlementUploaded(self, ):
4684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4685 
    if mtype == TMessageType.EXCEPTION:
4686 
      x = TApplicationException()
4687 
      x.read(self._iprot)
4688 
      self._iprot.readMessageEnd()
4689 
      raise x
4690 
    result = markEBSSettlementUploaded_result()
4691 
    result.read(self._iprot)
4692 
    self._iprot.readMessageEnd()
4693 
    if result.ex is not None:
4694 
      raise result.ex
4695 
    return
4696 
 
4697 
  def getEBSSettlementDate(self, settlementId):
4698 
    """
4699 
    Parameters:
4700 
     - settlementId
4701 
    """
4702 
    self.send_getEBSSettlementDate(settlementId)
4703 
    return self.recv_getEBSSettlementDate()
4704 
 
4705 
  def send_getEBSSettlementDate(self, settlementId):
4706 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4707 
    args = getEBSSettlementDate_args()
4708 
    args.settlementId = settlementId
4709 
    args.write(self._oprot)
4710 
    self._oprot.writeMessageEnd()
4711 
    self._oprot.trans.flush()
4712 
 
4713 
  def recv_getEBSSettlementDate(self, ):
4714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4715 
    if mtype == TMessageType.EXCEPTION:
4716 
      x = TApplicationException()
4717 
      x.read(self._iprot)
4718 
      self._iprot.readMessageEnd()
4719 
      raise x
4720 
    result = getEBSSettlementDate_result()
4721 
    result.read(self._iprot)
4722 
    self._iprot.readMessageEnd()
4723 
    if result.success is not None:
4724 
      return result.success
4725 
    if result.ex is not None:
4726 
      raise result.ex
4727 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4728 
 
4715 varun.gupt 4729 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4730 
    """
4731 
    Parameters:
4732 
     - settlementDateFrom
4733 
     - settlementDateTo
4734 
     - isRefund
4735 
    """
4736 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4737 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4738 
 
4715 varun.gupt 4739 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4740 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4741 
    args = getSettlementsByDate_args()
4742 
    args.settlementDateFrom = settlementDateFrom
4743 
    args.settlementDateTo = settlementDateTo
4744 
    args.isRefund = isRefund
4745 
    args.write(self._oprot)
4746 
    self._oprot.writeMessageEnd()
4747 
    self._oprot.trans.flush()
4748 
 
4749 
  def recv_getSettlementsByDate(self, ):
4750 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4751 
    if mtype == TMessageType.EXCEPTION:
4752 
      x = TApplicationException()
4753 
      x.read(self._iprot)
4754 
      self._iprot.readMessageEnd()
4755 
      raise x
4756 
    result = getSettlementsByDate_result()
4757 
    result.read(self._iprot)
4758 
    self._iprot.readMessageEnd()
4759 
    if result.success is not None:
4760 
      return result.success
4761 
    if result.ex is not None:
4762 
      raise result.ex
4763 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4764 
 
4765 
  def getReshippedOrderIds(self, orderIds):
4766 
    """
4767 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4768 
 
4769 
    Parameters:
4770 
     - orderIds
4771 
    """
4772 
    self.send_getReshippedOrderIds(orderIds)
4773 
    return self.recv_getReshippedOrderIds()
4774 
 
4775 
  def send_getReshippedOrderIds(self, orderIds):
4776 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4777 
    args = getReshippedOrderIds_args()
4778 
    args.orderIds = orderIds
4779 
    args.write(self._oprot)
4780 
    self._oprot.writeMessageEnd()
4781 
    self._oprot.trans.flush()
4782 
 
4783 
  def recv_getReshippedOrderIds(self, ):
4784 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4785 
    if mtype == TMessageType.EXCEPTION:
4786 
      x = TApplicationException()
4787 
      x.read(self._iprot)
4788 
      self._iprot.readMessageEnd()
4789 
      raise x
4790 
    result = getReshippedOrderIds_result()
4791 
    result.read(self._iprot)
4792 
    self._iprot.readMessageEnd()
4793 
    if result.success is not None:
4794 
      return result.success
4795 
    if result.ex is not None:
4796 
      raise result.ex
4797 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4798 
 
4757 mandeep.dh 4799 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4800 
    """
4801 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
4802 
    the quantities for which the PO is raised.
4715 varun.gupt 4803 
 
4757 mandeep.dh 4804 
    Parameters:
4805 
     - itemIdQuantityMap
4806 
     - purchaseOrderId
4807 
     - warehouseId
4808 
    """
4809 
    self.send_updateOrdersAsPORaised(itemIdQuantityMap, purchaseOrderId, warehouseId)
4810 
    self.recv_updateOrdersAsPORaised()
4811 
 
4812 
  def send_updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4813 
    self._oprot.writeMessageBegin('updateOrdersAsPORaised', TMessageType.CALL, self._seqid)
4814 
    args = updateOrdersAsPORaised_args()
4815 
    args.itemIdQuantityMap = itemIdQuantityMap
4816 
    args.purchaseOrderId = purchaseOrderId
4817 
    args.warehouseId = warehouseId
4818 
    args.write(self._oprot)
4819 
    self._oprot.writeMessageEnd()
4820 
    self._oprot.trans.flush()
4821 
 
4822 
  def recv_updateOrdersAsPORaised(self, ):
4823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4824 
    if mtype == TMessageType.EXCEPTION:
4825 
      x = TApplicationException()
4826 
      x.read(self._iprot)
4827 
      self._iprot.readMessageEnd()
4828 
      raise x
4829 
    result = updateOrdersAsPORaised_result()
4830 
    result.read(self._iprot)
4831 
    self._iprot.readMessageEnd()
4832 
    if result.ex is not None:
4833 
      raise result.ex
4834 
    return
4835 
 
4875 varun.gupt 4836 
  def getOrdersWhereVendorNotPaid(self, vendorId):
4837 
    """
4838 
    Parameters:
4839 
     - vendorId
4840 
    """
4841 
    self.send_getOrdersWhereVendorNotPaid(vendorId)
4842 
    return self.recv_getOrdersWhereVendorNotPaid()
4757 mandeep.dh 4843 
 
4875 varun.gupt 4844 
  def send_getOrdersWhereVendorNotPaid(self, vendorId):
4845 
    self._oprot.writeMessageBegin('getOrdersWhereVendorNotPaid', TMessageType.CALL, self._seqid)
4846 
    args = getOrdersWhereVendorNotPaid_args()
4847 
    args.vendorId = vendorId
4848 
    args.write(self._oprot)
4849 
    self._oprot.writeMessageEnd()
4850 
    self._oprot.trans.flush()
4851 
 
4852 
  def recv_getOrdersWhereVendorNotPaid(self, ):
4853 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4854 
    if mtype == TMessageType.EXCEPTION:
4855 
      x = TApplicationException()
4856 
      x.read(self._iprot)
4857 
      self._iprot.readMessageEnd()
4858 
      raise x
4859 
    result = getOrdersWhereVendorNotPaid_result()
4860 
    result.read(self._iprot)
4861 
    self._iprot.readMessageEnd()
4862 
    if result.success is not None:
4863 
      return result.success
4864 
    if result.ex is not None:
4865 
      raise result.ex
4866 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersWhereVendorNotPaid failed: unknown result");
4867 
 
5031 varun.gupt 4868 
  def getStatusDistributionOfOrders(self, startDate, endDate):
4869 
    """
4870 
    Parameters:
4871 
     - startDate
4872 
     - endDate
4873 
    """
4874 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
4875 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 4876 
 
5031 varun.gupt 4877 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
4878 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
4879 
    args = getStatusDistributionOfOrders_args()
4880 
    args.startDate = startDate
4881 
    args.endDate = endDate
4882 
    args.write(self._oprot)
4883 
    self._oprot.writeMessageEnd()
4884 
    self._oprot.trans.flush()
4885 
 
4886 
  def recv_getStatusDistributionOfOrders(self, ):
4887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4888 
    if mtype == TMessageType.EXCEPTION:
4889 
      x = TApplicationException()
4890 
      x.read(self._iprot)
4891 
      self._iprot.readMessageEnd()
4892 
      raise x
4893 
    result = getStatusDistributionOfOrders_result()
4894 
    result.read(self._iprot)
4895 
    self._iprot.readMessageEnd()
4896 
    if result.success is not None:
4897 
      return result.success
4898 
    if result.ex is not None:
4899 
      raise result.ex
4900 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
4901 
 
5067 varun.gupt 4902 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
4903 
    """
4904 
    Parameters:
4905 
     - status
4906 
     - startDatetime
4907 
     - endDatetime
4908 
    """
4909 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
4910 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 4911 
 
5067 varun.gupt 4912 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
4913 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
4914 
    args = getOrderIdsForStatus_args()
4915 
    args.status = status
4916 
    args.startDatetime = startDatetime
4917 
    args.endDatetime = endDatetime
4918 
    args.write(self._oprot)
4919 
    self._oprot.writeMessageEnd()
4920 
    self._oprot.trans.flush()
4921 
 
4922 
  def recv_getOrderIdsForStatus(self, ):
4923 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4924 
    if mtype == TMessageType.EXCEPTION:
4925 
      x = TApplicationException()
4926 
      x.read(self._iprot)
4927 
      self._iprot.readMessageEnd()
4928 
      raise x
4929 
    result = getOrderIdsForStatus_result()
4930 
    result.read(self._iprot)
4931 
    self._iprot.readMessageEnd()
4932 
    if result.success is not None:
4933 
      return result.success
4934 
    if result.ex is not None:
4935 
      raise result.ex
4936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
4937 
 
4938 
 
3376 rajveer 4939 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4940 
  def __init__(self, handler):
3376 rajveer 4941 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4942 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4943 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4944 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4945 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4946 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4947 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4948 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4949 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4950 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4951 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4952 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4953 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4954 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4955 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4956 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4957 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4958 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4959 
    self._processMap["createOrder"] = Processor.process_createOrder
4960 
    self._processMap["getOrder"] = Processor.process_getOrder
4961 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 4962 
    self._processMap["getOrderList"] = Processor.process_getOrderList
1528 ankur.sing 4963 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 4964 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 4965 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 4966 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 4967 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
4968 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
4969 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
4970 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 4971 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 4972 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 4973 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
4974 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
4975 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 4976 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 4977 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 4978 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 4979 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 4980 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 4981 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
4982 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 4983 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 4984 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
4985 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
4986 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
4987 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
4988 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 4989 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 4990 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 4991 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 4992 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 4993 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
4994 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 4995 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
4996 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 4997 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
4998 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 4999 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 5000 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 5001 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 5002 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 5003 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 5004 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 5005 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 5006 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
5007 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 5008 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 5009 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 5010 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 5011 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 5012 
    self._processMap["changeItem"] = Processor.process_changeItem
5013 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 5014 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 5015 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 5016 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
5017 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 5018 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 5019 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 5020 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
5021 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
5022 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 5023 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 5024 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 5025 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 5026 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 5027 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
5028 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
5029 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 5030 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 5031 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 5032 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 5033 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 5034 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 5035 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 5036 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 5037 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
5038 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
5039 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5040 
    self._processMap["getSettlementForPaymentId"] = Processor.process_getSettlementForPaymentId
5041 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
5042 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
5043 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 5044 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
5045 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
4757 mandeep.dh 5046 
    self._processMap["updateOrdersAsPORaised"] = Processor.process_updateOrdersAsPORaised
4875 varun.gupt 5047 
    self._processMap["getOrdersWhereVendorNotPaid"] = Processor.process_getOrdersWhereVendorNotPaid
5031 varun.gupt 5048 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 5049 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
94 ashish 5050 
 
5051 
  def process(self, iprot, oprot):
5052 
    (name, type, seqid) = iprot.readMessageBegin()
5053 
    if name not in self._processMap:
5054 
      iprot.skip(TType.STRUCT)
5055 
      iprot.readMessageEnd()
5056 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5057 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5058 
      x.write(oprot)
5059 
      oprot.writeMessageEnd()
5060 
      oprot.trans.flush()
5061 
      return
5062 
    else:
5063 
      self._processMap[name](self, seqid, iprot, oprot)
5064 
    return True
5065 
 
5066 
  def process_createTransaction(self, seqid, iprot, oprot):
5067 
    args = createTransaction_args()
5068 
    args.read(iprot)
5069 
    iprot.readMessageEnd()
5070 
    result = createTransaction_result()
5071 
    try:
132 ashish 5072 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 5073 
    except TransactionServiceException, ex:
5074 
      result.ex = ex
5075 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
5076 
    result.write(oprot)
5077 
    oprot.writeMessageEnd()
5078 
    oprot.trans.flush()
5079 
 
5080 
  def process_getTransaction(self, seqid, iprot, oprot):
5081 
    args = getTransaction_args()
5082 
    args.read(iprot)
5083 
    iprot.readMessageEnd()
5084 
    result = getTransaction_result()
5085 
    try:
5086 
      result.success = self._handler.getTransaction(args.id)
5087 
    except TransactionServiceException, ex:
5088 
      result.ex = ex
5089 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
5090 
    result.write(oprot)
5091 
    oprot.writeMessageEnd()
5092 
    oprot.trans.flush()
5093 
 
5094 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
5095 
    args = getTransactionsForCustomer_args()
5096 
    args.read(iprot)
5097 
    iprot.readMessageEnd()
5098 
    result = getTransactionsForCustomer_result()
5099 
    try:
5100 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
5101 
    except TransactionServiceException, ex:
5102 
      result.ex = ex
5103 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
5104 
    result.write(oprot)
5105 
    oprot.writeMessageEnd()
5106 
    oprot.trans.flush()
5107 
 
132 ashish 5108 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
5109 
    args = getTransactionsForShoppingCartId_args()
5110 
    args.read(iprot)
5111 
    iprot.readMessageEnd()
5112 
    result = getTransactionsForShoppingCartId_result()
5113 
    try:
5114 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
5115 
    except TransactionServiceException, ex:
5116 
      result.ex = ex
5117 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
5118 
    result.write(oprot)
5119 
    oprot.writeMessageEnd()
5120 
    oprot.trans.flush()
5121 
 
94 ashish 5122 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
5123 
    args = getTransactionStatus_args()
5124 
    args.read(iprot)
5125 
    iprot.readMessageEnd()
5126 
    result = getTransactionStatus_result()
5127 
    try:
5128 
      result.success = self._handler.getTransactionStatus(args.transactionId)
5129 
    except TransactionServiceException, ex:
5130 
      result.ex = ex
5131 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
5132 
    result.write(oprot)
5133 
    oprot.writeMessageEnd()
5134 
    oprot.trans.flush()
5135 
 
5136 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
5137 
    args = changeTransactionStatus_args()
5138 
    args.read(iprot)
5139 
    iprot.readMessageEnd()
5140 
    result = changeTransactionStatus_result()
5141 
    try:
5142 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
5143 
    except TransactionServiceException, ex:
5144 
      result.ex = ex
5145 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
5146 
    result.write(oprot)
5147 
    oprot.writeMessageEnd()
5148 
    oprot.trans.flush()
5149 
 
1398 varun.gupt 5150 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
5151 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 5152 
    args.read(iprot)
5153 
    iprot.readMessageEnd()
1398 varun.gupt 5154 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 5155 
    try:
1398 varun.gupt 5156 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 5157 
    except TransactionServiceException, ex:
5158 
      result.ex = ex
1398 varun.gupt 5159 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 5160 
    result.write(oprot)
5161 
    oprot.writeMessageEnd()
5162 
    oprot.trans.flush()
5163 
 
483 rajveer 5164 
  def process_getAllOrders(self, seqid, iprot, oprot):
5165 
    args = getAllOrders_args()
94 ashish 5166 
    args.read(iprot)
5167 
    iprot.readMessageEnd()
483 rajveer 5168 
    result = getAllOrders_result()
94 ashish 5169 
    try:
4801 anupam.sin 5170 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 5171 
    except TransactionServiceException, ex:
5172 
      result.ex = ex
483 rajveer 5173 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 5174 
    result.write(oprot)
5175 
    oprot.writeMessageEnd()
5176 
    oprot.trans.flush()
5177 
 
4133 chandransh 5178 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
5179 
    args = getOrdersInBatch_args()
5180 
    args.read(iprot)
5181 
    iprot.readMessageEnd()
5182 
    result = getOrdersInBatch_result()
5183 
    try:
5184 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
5185 
    except TransactionServiceException, ex:
5186 
      result.ex = ex
5187 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
5188 
    result.write(oprot)
5189 
    oprot.writeMessageEnd()
5190 
    oprot.trans.flush()
5191 
 
5192 
  def process_getOrderCount(self, seqid, iprot, oprot):
5193 
    args = getOrderCount_args()
5194 
    args.read(iprot)
5195 
    iprot.readMessageEnd()
5196 
    result = getOrderCount_result()
5197 
    try:
5198 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
5199 
    except TransactionServiceException, ex:
5200 
      result.ex = ex
5201 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
5202 
    result.write(oprot)
5203 
    oprot.writeMessageEnd()
5204 
    oprot.trans.flush()
5205 
 
999 varun.gupt 5206 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
5207 
    args = getOrdersByBillingDate_args()
5208 
    args.read(iprot)
5209 
    iprot.readMessageEnd()
5210 
    result = getOrdersByBillingDate_result()
5211 
    try:
5212 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
5213 
    except TransactionServiceException, ex:
5214 
      result.ex = ex
5215 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
5216 
    result.write(oprot)
5217 
    oprot.writeMessageEnd()
5218 
    oprot.trans.flush()
5219 
 
3427 chandransh 5220 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
5221 
    args = getOrdersByShippingDate_args()
5222 
    args.read(iprot)
5223 
    iprot.readMessageEnd()
5224 
    result = getOrdersByShippingDate_result()
5225 
    try:
3451 chandransh 5226 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 5227 
    except TransactionServiceException, ex:
5228 
      result.ex = ex
5229 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
5230 
    result.write(oprot)
5231 
    oprot.writeMessageEnd()
5232 
    oprot.trans.flush()
5233 
 
1382 varun.gupt 5234 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
5235 
    args = getReturnableOrdersForCustomer_args()
5236 
    args.read(iprot)
5237 
    iprot.readMessageEnd()
5238 
    result = getReturnableOrdersForCustomer_result()
5239 
    try:
5240 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
5241 
    except TransactionServiceException, ex:
5242 
      result.ex = ex
5243 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
5244 
    result.write(oprot)
5245 
    oprot.writeMessageEnd()
5246 
    oprot.trans.flush()
5247 
 
5248 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
5249 
    args = getCancellableOrdersForCustomer_args()
5250 
    args.read(iprot)
5251 
    iprot.readMessageEnd()
5252 
    result = getCancellableOrdersForCustomer_result()
5253 
    try:
5254 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
5255 
    except TransactionServiceException, ex:
5256 
      result.ex = ex
5257 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
5258 
    result.write(oprot)
5259 
    oprot.writeMessageEnd()
5260 
    oprot.trans.flush()
5261 
 
483 rajveer 5262 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
5263 
    args = changeOrderStatus_args()
94 ashish 5264 
    args.read(iprot)
5265 
    iprot.readMessageEnd()
483 rajveer 5266 
    result = changeOrderStatus_result()
94 ashish 5267 
    try:
483 rajveer 5268 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 5269 
    except TransactionServiceException, ex:
5270 
      result.ex = ex
483 rajveer 5271 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 5272 
    result.write(oprot)
5273 
    oprot.writeMessageEnd()
5274 
    oprot.trans.flush()
5275 
 
483 rajveer 5276 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
5277 
    args = getOrdersForTransaction_args()
94 ashish 5278 
    args.read(iprot)
5279 
    iprot.readMessageEnd()
483 rajveer 5280 
    result = getOrdersForTransaction_result()
94 ashish 5281 
    try:
1528 ankur.sing 5282 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 5283 
    except TransactionServiceException, ex:
5284 
      result.ex = ex
483 rajveer 5285 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 5286 
    result.write(oprot)
5287 
    oprot.writeMessageEnd()
5288 
    oprot.trans.flush()
5289 
 
483 rajveer 5290 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
5291 
    args = getOrdersForCustomer_args()
94 ashish 5292 
    args.read(iprot)
5293 
    iprot.readMessageEnd()
483 rajveer 5294 
    result = getOrdersForCustomer_result()
94 ashish 5295 
    try:
3014 chandransh 5296 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 5297 
    except TransactionServiceException, ex:
5298 
      result.ex = ex
483 rajveer 5299 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 5300 
    result.write(oprot)
5301 
    oprot.writeMessageEnd()
5302 
    oprot.trans.flush()
5303 
 
483 rajveer 5304 
  def process_createOrder(self, seqid, iprot, oprot):
5305 
    args = createOrder_args()
94 ashish 5306 
    args.read(iprot)
5307 
    iprot.readMessageEnd()
483 rajveer 5308 
    result = createOrder_result()
94 ashish 5309 
    try:
483 rajveer 5310 
      result.success = self._handler.createOrder(args.order)
94 ashish 5311 
    except TransactionServiceException, ex:
5312 
      result.ex = ex
483 rajveer 5313 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 5314 
    result.write(oprot)
5315 
    oprot.writeMessageEnd()
5316 
    oprot.trans.flush()
5317 
 
483 rajveer 5318 
  def process_getOrder(self, seqid, iprot, oprot):
5319 
    args = getOrder_args()
94 ashish 5320 
    args.read(iprot)
5321 
    iprot.readMessageEnd()
483 rajveer 5322 
    result = getOrder_result()
94 ashish 5323 
    try:
483 rajveer 5324 
      result.success = self._handler.getOrder(args.id)
94 ashish 5325 
    except TransactionServiceException, ex:
5326 
      result.ex = ex
483 rajveer 5327 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 5328 
    result.write(oprot)
5329 
    oprot.writeMessageEnd()
5330 
    oprot.trans.flush()
5331 
 
483 rajveer 5332 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
5333 
    args = getLineItemsForOrder_args()
94 ashish 5334 
    args.read(iprot)
5335 
    iprot.readMessageEnd()
483 rajveer 5336 
    result = getLineItemsForOrder_result()
94 ashish 5337 
    try:
483 rajveer 5338 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 5339 
    except TransactionServiceException, ex:
5340 
      result.ex = ex
483 rajveer 5341 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 5342 
    result.write(oprot)
5343 
    oprot.writeMessageEnd()
5344 
    oprot.trans.flush()
5345 
 
4999 phani.kuma 5346 
  def process_getOrderList(self, seqid, iprot, oprot):
5347 
    args = getOrderList_args()
5348 
    args.read(iprot)
5349 
    iprot.readMessageEnd()
5350 
    result = getOrderList_result()
5351 
    result.success = self._handler.getOrderList(args.order_ids)
5352 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
5353 
    result.write(oprot)
5354 
    oprot.writeMessageEnd()
5355 
    oprot.trans.flush()
5356 
 
1528 ankur.sing 5357 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
5358 
    args = getOrderForCustomer_args()
5359 
    args.read(iprot)
5360 
    iprot.readMessageEnd()
5361 
    result = getOrderForCustomer_result()
5362 
    try:
5363 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
5364 
    except TransactionServiceException, ex:
5365 
      result.ex = ex
5366 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
5367 
    result.write(oprot)
5368 
    oprot.writeMessageEnd()
5369 
    oprot.trans.flush()
5370 
 
3064 chandransh 5371 
  def process_getAlerts(self, seqid, iprot, oprot):
5372 
    args = getAlerts_args()
5373 
    args.read(iprot)
5374 
    iprot.readMessageEnd()
5375 
    result = getAlerts_result()
4444 rajveer 5376 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 5377 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
5378 
    result.write(oprot)
5379 
    oprot.writeMessageEnd()
5380 
    oprot.trans.flush()
5381 
 
4394 rajveer 5382 
  def process_addAlert(self, seqid, iprot, oprot):
5383 
    args = addAlert_args()
3064 chandransh 5384 
    args.read(iprot)
5385 
    iprot.readMessageEnd()
4394 rajveer 5386 
    result = addAlert_result()
4444 rajveer 5387 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 5388 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 5389 
    result.write(oprot)
5390 
    oprot.writeMessageEnd()
5391 
    oprot.trans.flush()
5392 
 
4444 rajveer 5393 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
5394 
    args = markAlertsAsSeen_args()
5395 
    args.read(iprot)
5396 
    iprot.readMessageEnd()
5397 
    result = markAlertsAsSeen_result()
5398 
    self._handler.markAlertsAsSeen(args.warehouseId)
5399 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
5400 
    result.write(oprot)
5401 
    oprot.writeMessageEnd()
5402 
    oprot.trans.flush()
5403 
 
3064 chandransh 5404 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
5405 
    args = getValidOrderCount_args()
5406 
    args.read(iprot)
5407 
    iprot.readMessageEnd()
5408 
    result = getValidOrderCount_result()
5409 
    result.success = self._handler.getValidOrderCount()
5410 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
5411 
    result.write(oprot)
5412 
    oprot.writeMessageEnd()
5413 
    oprot.trans.flush()
5414 
 
5415 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
5416 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
5417 
    args.read(iprot)
5418 
    iprot.readMessageEnd()
5419 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
5420 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
5421 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
5422 
    result.write(oprot)
5423 
    oprot.writeMessageEnd()
5424 
    oprot.trans.flush()
5425 
 
5426 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
5427 
    args = getValidOrdersAmountRange_args()
5428 
    args.read(iprot)
5429 
    iprot.readMessageEnd()
5430 
    result = getValidOrdersAmountRange_result()
5431 
    result.success = self._handler.getValidOrdersAmountRange()
5432 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
5433 
    result.write(oprot)
5434 
    oprot.writeMessageEnd()
5435 
    oprot.trans.flush()
5436 
 
5437 
  def process_getValidOrders(self, seqid, iprot, oprot):
5438 
    args = getValidOrders_args()
5439 
    args.read(iprot)
5440 
    iprot.readMessageEnd()
5441 
    result = getValidOrders_result()
5442 
    result.success = self._handler.getValidOrders(args.limit)
5443 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
5444 
    result.write(oprot)
5445 
    oprot.writeMessageEnd()
5446 
    oprot.trans.flush()
5447 
 
1220 chandransh 5448 
  def process_batchOrders(self, seqid, iprot, oprot):
5449 
    args = batchOrders_args()
5450 
    args.read(iprot)
5451 
    iprot.readMessageEnd()
5452 
    result = batchOrders_result()
5453 
    try:
5454 
      result.success = self._handler.batchOrders(args.warehouseId)
5455 
    except TransactionServiceException, ex:
5456 
      result.ex = ex
5457 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
5458 
    result.write(oprot)
5459 
    oprot.writeMessageEnd()
5460 
    oprot.trans.flush()
5461 
 
1208 chandransh 5462 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
5463 
    args = markOrderAsOutOfStock_args()
5464 
    args.read(iprot)
5465 
    iprot.readMessageEnd()
5466 
    result = markOrderAsOutOfStock_result()
5467 
    try:
5468 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
5469 
    except TransactionServiceException, ex:
5470 
      result.ex = ex
5471 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
5472 
    result.write(oprot)
5473 
    oprot.writeMessageEnd()
5474 
    oprot.trans.flush()
5475 
 
3064 chandransh 5476 
  def process_verifyOrder(self, seqid, iprot, oprot):
5477 
    args = verifyOrder_args()
759 chandransh 5478 
    args.read(iprot)
5479 
    iprot.readMessageEnd()
3064 chandransh 5480 
    result = verifyOrder_result()
759 chandransh 5481 
    try:
3064 chandransh 5482 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 5483 
    except TransactionServiceException, ex:
5484 
      result.ex = ex
3064 chandransh 5485 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 5486 
    result.write(oprot)
5487 
    oprot.writeMessageEnd()
5488 
    oprot.trans.flush()
5489 
 
3064 chandransh 5490 
  def process_acceptOrder(self, seqid, iprot, oprot):
5491 
    args = acceptOrder_args()
1113 chandransh 5492 
    args.read(iprot)
5493 
    iprot.readMessageEnd()
3064 chandransh 5494 
    result = acceptOrder_result()
1113 chandransh 5495 
    try:
3064 chandransh 5496 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 5497 
    except TransactionServiceException, ex:
5498 
      result.ex = ex
3064 chandransh 5499 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 5500 
    result.write(oprot)
5501 
    oprot.writeMessageEnd()
5502 
    oprot.trans.flush()
5503 
 
3064 chandransh 5504 
  def process_addBillingDetails(self, seqid, iprot, oprot):
5505 
    args = addBillingDetails_args()
1135 chandransh 5506 
    args.read(iprot)
5507 
    iprot.readMessageEnd()
3064 chandransh 5508 
    result = addBillingDetails_result()
1135 chandransh 5509 
    try:
4763 rajveer 5510 
      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 5511 
    except TransactionServiceException, ex:
5512 
      result.ex = ex
3064 chandransh 5513 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 5514 
    result.write(oprot)
5515 
    oprot.writeMessageEnd()
5516 
    oprot.trans.flush()
5517 
 
4579 rajveer 5518 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
5519 
    args = addInvoiceNumber_args()
5520 
    args.read(iprot)
5521 
    iprot.readMessageEnd()
5522 
    result = addInvoiceNumber_result()
5523 
    try:
4763 rajveer 5524 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 5525 
    except TransactionServiceException, ex:
5526 
      result.ex = ex
5527 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
5528 
    result.write(oprot)
5529 
    oprot.writeMessageEnd()
5530 
    oprot.trans.flush()
5531 
 
4410 rajveer 5532 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5533 
    args = markOrdersAsShippedFromWarehouse_args()
5534 
    args.read(iprot)
5535 
    iprot.readMessageEnd()
5536 
    result = markOrdersAsShippedFromWarehouse_result()
5537 
    try:
4789 rajveer 5538 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 5539 
    except TransactionServiceException, ex:
5540 
      result.ex = ex
5541 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5542 
    result.write(oprot)
5543 
    oprot.writeMessageEnd()
5544 
    oprot.trans.flush()
5545 
 
3064 chandransh 5546 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5547 
    args = markOrdersAsPickedUp_args()
304 ashish 5548 
    args.read(iprot)
5549 
    iprot.readMessageEnd()
3064 chandransh 5550 
    result = markOrdersAsPickedUp_result()
5551 
    try:
4910 phani.kuma 5552 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 5553 
    except TransactionServiceException, ex:
5554 
      result.ex = ex
5555 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5556 
    result.write(oprot)
5557 
    oprot.writeMessageEnd()
5558 
    oprot.trans.flush()
94 ashish 5559 
 
4910 phani.kuma 5560 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
5561 
    args = getOrdersNotPickedUp_args()
5562 
    args.read(iprot)
5563 
    iprot.readMessageEnd()
5564 
    result = getOrdersNotPickedUp_result()
5565 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
5566 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
5567 
    result.write(oprot)
5568 
    oprot.writeMessageEnd()
5569 
    oprot.trans.flush()
5570 
 
3064 chandransh 5571 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5572 
    args = markOrdersAsDelivered_args()
304 ashish 5573 
    args.read(iprot)
5574 
    iprot.readMessageEnd()
3064 chandransh 5575 
    result = markOrdersAsDelivered_result()
5576 
    try:
5577 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5578 
    except TransactionServiceException, ex:
5579 
      result.ex = ex
5580 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5581 
    result.write(oprot)
5582 
    oprot.writeMessageEnd()
5583 
    oprot.trans.flush()
5584 
 
4910 phani.kuma 5585 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
5586 
    args = markAsRTOrders_args()
1596 ankur.sing 5587 
    args.read(iprot)
5588 
    iprot.readMessageEnd()
4910 phani.kuma 5589 
    result = markAsRTOrders_result()
3064 chandransh 5590 
    try:
4910 phani.kuma 5591 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 5592 
    except TransactionServiceException, ex:
5593 
      result.ex = ex
4910 phani.kuma 5594 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 5595 
    result.write(oprot)
5596 
    oprot.writeMessageEnd()
5597 
    oprot.trans.flush()
304 ashish 5598 
 
4910 phani.kuma 5599 
  def process_getRTOrders(self, seqid, iprot, oprot):
5600 
    args = getRTOrders_args()
5601 
    args.read(iprot)
5602 
    iprot.readMessageEnd()
5603 
    result = getRTOrders_result()
5604 
    result.success = self._handler.getRTOrders(args.providerId)
5605 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
5606 
    result.write(oprot)
5607 
    oprot.writeMessageEnd()
5608 
    oprot.trans.flush()
5609 
 
3064 chandransh 5610 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5611 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5612 
    args.read(iprot)
5613 
    iprot.readMessageEnd()
3064 chandransh 5614 
    result = updateNonDeliveryReason_result()
5615 
    try:
4910 phani.kuma 5616 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5617 
    except TransactionServiceException, ex:
5618 
      result.ex = ex
5619 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5620 
    result.write(oprot)
5621 
    oprot.writeMessageEnd()
5622 
    oprot.trans.flush()
1596 ankur.sing 5623 
 
4910 phani.kuma 5624 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
5625 
    args = getNonDeliveredOrdersbyCourier_args()
5626 
    args.read(iprot)
5627 
    iprot.readMessageEnd()
5628 
    result = getNonDeliveredOrdersbyCourier_result()
5629 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
5630 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
5631 
    result.write(oprot)
5632 
    oprot.writeMessageEnd()
5633 
    oprot.trans.flush()
5634 
 
5635 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
5636 
    args = markOrdersAsLocalConnected_args()
5637 
    args.read(iprot)
5638 
    iprot.readMessageEnd()
5639 
    result = markOrdersAsLocalConnected_result()
5640 
    try:
5641 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
5642 
    except TransactionServiceException, ex:
5643 
      result.ex = ex
5644 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
5645 
    result.write(oprot)
5646 
    oprot.writeMessageEnd()
5647 
    oprot.trans.flush()
5648 
 
5649 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
5650 
    args = getOrdersNotLocalConnected_args()
5651 
    args.read(iprot)
5652 
    iprot.readMessageEnd()
5653 
    result = getOrdersNotLocalConnected_result()
5654 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
5655 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
5656 
    result.write(oprot)
5657 
    oprot.writeMessageEnd()
5658 
    oprot.trans.flush()
5659 
 
5660 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
5661 
    args = markOrdersAsDestinationCityReached_args()
5662 
    args.read(iprot)
5663 
    iprot.readMessageEnd()
5664 
    result = markOrdersAsDestinationCityReached_result()
5665 
    try:
5666 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
5667 
    except TransactionServiceException, ex:
5668 
      result.ex = ex
5669 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
5670 
    result.write(oprot)
5671 
    oprot.writeMessageEnd()
5672 
    oprot.trans.flush()
5673 
 
5674 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
5675 
    args = markOrdersAsFirstDeliveryAttempted_args()
5676 
    args.read(iprot)
5677 
    iprot.readMessageEnd()
5678 
    result = markOrdersAsFirstDeliveryAttempted_result()
5679 
    try:
5680 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
5681 
    except TransactionServiceException, ex:
5682 
      result.ex = ex
5683 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
5684 
    result.write(oprot)
5685 
    oprot.writeMessageEnd()
5686 
    oprot.trans.flush()
5687 
 
3064 chandransh 5688 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5689 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5690 
    args.read(iprot)
5691 
    iprot.readMessageEnd()
3064 chandransh 5692 
    result = getUndeliveredOrders_result()
5693 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5694 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5695 
    result.write(oprot)
5696 
    oprot.writeMessageEnd()
5697 
    oprot.trans.flush()
5698 
 
4783 phani.kuma 5699 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
5700 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
5701 
    args.read(iprot)
5702 
    iprot.readMessageEnd()
5703 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
5704 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
5705 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
5706 
    result.write(oprot)
5707 
    oprot.writeMessageEnd()
5708 
    oprot.trans.flush()
5709 
 
2536 chandransh 5710 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5711 
    args = toggleDOAFlag_args()
5712 
    args.read(iprot)
5713 
    iprot.readMessageEnd()
5714 
    result = toggleDOAFlag_result()
5715 
    try:
5716 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5717 
    except TransactionServiceException, ex:
5718 
      result.ex = ex
5719 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5720 
    result.write(oprot)
5721 
    oprot.writeMessageEnd()
5722 
    oprot.trans.flush()
1886 ankur.sing 5723 
 
4712 rajveer 5724 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5725 
    args = markOrderAsDelivered_args()
5726 
    args.read(iprot)
5727 
    iprot.readMessageEnd()
5728 
    result = markOrderAsDelivered_result()
5729 
    try:
5730 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5731 
    except TransactionServiceException, ex:
5732 
      result.ex = ex
5733 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5734 
    result.write(oprot)
5735 
    oprot.writeMessageEnd()
5736 
    oprot.trans.flush()
5737 
 
4454 rajveer 5738 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5739 
    args = markOrderDoaRequestReceived_args()
5740 
    args.read(iprot)
5741 
    iprot.readMessageEnd()
5742 
    result = markOrderDoaRequestReceived_result()
5743 
    try:
5744 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5745 
    except TransactionServiceException, ex:
5746 
      result.ex = ex
5747 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5748 
    result.write(oprot)
5749 
    oprot.writeMessageEnd()
5750 
    oprot.trans.flush()
5751 
 
5752 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
5753 
    args = markOrderDoaRequestAuthorized_args()
5754 
    args.read(iprot)
5755 
    iprot.readMessageEnd()
5756 
    result = markOrderDoaRequestAuthorized_result()
5757 
    try:
5758 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
5759 
    except TransactionServiceException, ex:
5760 
      result.ex = ex
5761 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
5762 
    result.write(oprot)
5763 
    oprot.writeMessageEnd()
5764 
    oprot.trans.flush()
5765 
 
4488 rajveer 5766 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5767 
    args = markOrderReturnRequestReceived_args()
5768 
    args.read(iprot)
5769 
    iprot.readMessageEnd()
5770 
    result = markOrderReturnRequestReceived_result()
5771 
    try:
5772 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5773 
    except TransactionServiceException, ex:
5774 
      result.ex = ex
5775 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5776 
    result.write(oprot)
5777 
    oprot.writeMessageEnd()
5778 
    oprot.trans.flush()
5779 
 
5780 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5781 
    args = markOrderReturnRequestAuthorized_args()
5782 
    args.read(iprot)
5783 
    iprot.readMessageEnd()
5784 
    result = markOrderReturnRequestAuthorized_result()
5785 
    try:
5786 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5787 
    except TransactionServiceException, ex:
5788 
      result.ex = ex
5789 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5790 
    result.write(oprot)
5791 
    oprot.writeMessageEnd()
5792 
    oprot.trans.flush()
5793 
 
2536 chandransh 5794 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5795 
    args = requestPickupNumber_args()
5796 
    args.read(iprot)
5797 
    iprot.readMessageEnd()
5798 
    result = requestPickupNumber_result()
5799 
    try:
4579 rajveer 5800 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 5801 
    except TransactionServiceException, ex:
5802 
      result.ex = ex
5803 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
5804 
    result.write(oprot)
5805 
    oprot.writeMessageEnd()
5806 
    oprot.trans.flush()
5807 
 
5808 
  def process_authorizePickup(self, seqid, iprot, oprot):
5809 
    args = authorizePickup_args()
5810 
    args.read(iprot)
5811 
    iprot.readMessageEnd()
5812 
    result = authorizePickup_result()
5813 
    try:
4602 rajveer 5814 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 5815 
    except TransactionServiceException, ex:
5816 
      result.ex = ex
5817 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
5818 
    result.write(oprot)
5819 
    oprot.writeMessageEnd()
5820 
    oprot.trans.flush()
5821 
 
2764 chandransh 5822 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
5823 
    args = markDoasAsPickedUp_args()
5824 
    args.read(iprot)
5825 
    iprot.readMessageEnd()
5826 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 5827 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 5828 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
5829 
    result.write(oprot)
5830 
    oprot.writeMessageEnd()
5831 
    oprot.trans.flush()
5832 
 
4910 phani.kuma 5833 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
5834 
    args = getDoasNotPickedUp_args()
5835 
    args.read(iprot)
5836 
    iprot.readMessageEnd()
5837 
    result = getDoasNotPickedUp_result()
5838 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
5839 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
5840 
    result.write(oprot)
5841 
    oprot.writeMessageEnd()
5842 
    oprot.trans.flush()
5843 
 
4741 phani.kuma 5844 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
5845 
    args = markReturnOrdersAsPickedUp_args()
5846 
    args.read(iprot)
5847 
    iprot.readMessageEnd()
5848 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 5849 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 5850 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
5851 
    result.write(oprot)
5852 
    oprot.writeMessageEnd()
5853 
    oprot.trans.flush()
5854 
 
4910 phani.kuma 5855 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
5856 
    args = getReturnOrdersNotPickedUp_args()
5857 
    args.read(iprot)
5858 
    iprot.readMessageEnd()
5859 
    result = getReturnOrdersNotPickedUp_result()
5860 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
5861 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
5862 
    result.write(oprot)
5863 
    oprot.writeMessageEnd()
5864 
    oprot.trans.flush()
5865 
 
2616 chandransh 5866 
  def process_receiveReturn(self, seqid, iprot, oprot):
5867 
    args = receiveReturn_args()
2591 chandransh 5868 
    args.read(iprot)
5869 
    iprot.readMessageEnd()
2616 chandransh 5870 
    result = receiveReturn_result()
2591 chandransh 5871 
    try:
4479 rajveer 5872 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 5873 
    except TransactionServiceException, ex:
5874 
      result.ex = ex
2616 chandransh 5875 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 5876 
    result.write(oprot)
5877 
    oprot.writeMessageEnd()
5878 
    oprot.trans.flush()
2536 chandransh 5879 
 
2591 chandransh 5880 
  def process_validateDoa(self, seqid, iprot, oprot):
5881 
    args = validateDoa_args()
5882 
    args.read(iprot)
5883 
    iprot.readMessageEnd()
5884 
    result = validateDoa_result()
5885 
    try:
5886 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
5887 
    except TransactionServiceException, ex:
5888 
      result.ex = ex
5889 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
5890 
    result.write(oprot)
5891 
    oprot.writeMessageEnd()
5892 
    oprot.trans.flush()
5893 
 
4495 rajveer 5894 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
5895 
    args = validateReturnProduct_args()
5896 
    args.read(iprot)
5897 
    iprot.readMessageEnd()
5898 
    result = validateReturnProduct_result()
5899 
    try:
5900 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
5901 
    except TransactionServiceException, ex:
5902 
      result.ex = ex
5903 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
5904 
    result.write(oprot)
5905 
    oprot.writeMessageEnd()
5906 
    oprot.trans.flush()
5907 
 
2616 chandransh 5908 
  def process_reshipOrder(self, seqid, iprot, oprot):
5909 
    args = reshipOrder_args()
5910 
    args.read(iprot)
5911 
    iprot.readMessageEnd()
5912 
    result = reshipOrder_result()
5913 
    try:
5914 
      result.success = self._handler.reshipOrder(args.orderId)
5915 
    except TransactionServiceException, ex:
5916 
      result.ex = ex
5917 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
5918 
    result.write(oprot)
5919 
    oprot.writeMessageEnd()
5920 
    oprot.trans.flush()
2591 chandransh 5921 
 
2616 chandransh 5922 
  def process_refundOrder(self, seqid, iprot, oprot):
5923 
    args = refundOrder_args()
5924 
    args.read(iprot)
5925 
    iprot.readMessageEnd()
5926 
    result = refundOrder_result()
5927 
    try:
3226 chandransh 5928 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 5929 
    except TransactionServiceException, ex:
5930 
      result.ex = ex
5931 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
5932 
    result.write(oprot)
5933 
    oprot.writeMessageEnd()
5934 
    oprot.trans.flush()
5935 
 
2690 chandransh 5936 
  def process_getReturnOrders(self, seqid, iprot, oprot):
5937 
    args = getReturnOrders_args()
5938 
    args.read(iprot)
5939 
    iprot.readMessageEnd()
5940 
    result = getReturnOrders_result()
5941 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
5942 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
5943 
    result.write(oprot)
5944 
    oprot.writeMessageEnd()
5945 
    oprot.trans.flush()
2616 chandransh 5946 
 
2700 chandransh 5947 
  def process_getReturnOrder(self, seqid, iprot, oprot):
5948 
    args = getReturnOrder_args()
5949 
    args.read(iprot)
5950 
    iprot.readMessageEnd()
5951 
    result = getReturnOrder_result()
5952 
    try:
5953 
      result.success = self._handler.getReturnOrder(args.id)
5954 
    except TransactionServiceException, ex:
5955 
      result.ex = ex
5956 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
5957 
    result.write(oprot)
5958 
    oprot.writeMessageEnd()
5959 
    oprot.trans.flush()
5960 
 
2690 chandransh 5961 
  def process_processReturn(self, seqid, iprot, oprot):
5962 
    args = processReturn_args()
5963 
    args.read(iprot)
5964 
    iprot.readMessageEnd()
5965 
    result = processReturn_result()
5966 
    try:
5967 
      self._handler.processReturn(args.returnOrderId)
5968 
    except TransactionServiceException, ex:
5969 
      result.ex = ex
5970 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
5971 
    result.write(oprot)
5972 
    oprot.writeMessageEnd()
5973 
    oprot.trans.flush()
5974 
 
3451 chandransh 5975 
  def process_updateWeight(self, seqid, iprot, oprot):
5976 
    args = updateWeight_args()
5977 
    args.read(iprot)
5978 
    iprot.readMessageEnd()
5979 
    result = updateWeight_result()
5980 
    try:
5981 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
5982 
    except TransactionServiceException, ex:
5983 
      result.ex = ex
5984 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
5985 
    result.write(oprot)
5986 
    oprot.writeMessageEnd()
5987 
    oprot.trans.flush()
2819 chandransh 5988 
 
3469 chandransh 5989 
  def process_changeItem(self, seqid, iprot, oprot):
5990 
    args = changeItem_args()
5991 
    args.read(iprot)
5992 
    iprot.readMessageEnd()
5993 
    result = changeItem_result()
5994 
    try:
5995 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
5996 
    except TransactionServiceException, ex:
5997 
      result.ex = ex
5998 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
5999 
    result.write(oprot)
6000 
    oprot.writeMessageEnd()
6001 
    oprot.trans.flush()
3451 chandransh 6002 
 
3469 chandransh 6003 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
6004 
    args = shiftToWarehouse_args()
6005 
    args.read(iprot)
6006 
    iprot.readMessageEnd()
6007 
    result = shiftToWarehouse_result()
6008 
    try:
6009 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
6010 
    except TransactionServiceException, ex:
6011 
      result.ex = ex
6012 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
6013 
    result.write(oprot)
6014 
    oprot.writeMessageEnd()
6015 
    oprot.trans.flush()
6016 
 
3553 chandransh 6017 
  def process_addDelayReason(self, seqid, iprot, oprot):
6018 
    args = addDelayReason_args()
6019 
    args.read(iprot)
6020 
    iprot.readMessageEnd()
6021 
    result = addDelayReason_result()
6022 
    try:
4647 rajveer 6023 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 6024 
    except TransactionServiceException, ex:
6025 
      result.ex = ex
6026 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
6027 
    result.write(oprot)
6028 
    oprot.writeMessageEnd()
6029 
    oprot.trans.flush()
3469 chandransh 6030 
 
3956 chandransh 6031 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
6032 
    args = reconcileCodCollection_args()
6033 
    args.read(iprot)
6034 
    iprot.readMessageEnd()
6035 
    result = reconcileCodCollection_result()
6036 
    try:
6037 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
6038 
    except TransactionServiceException, ex:
6039 
      result.ex = ex
6040 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
6041 
    result.write(oprot)
6042 
    oprot.writeMessageEnd()
6043 
    oprot.trans.flush()
3553 chandransh 6044 
 
4008 mandeep.dh 6045 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
6046 
    args = getTransactionsRequiringExtraProcessing_args()
6047 
    args.read(iprot)
6048 
    iprot.readMessageEnd()
6049 
    result = getTransactionsRequiringExtraProcessing_result()
6050 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
6051 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
6052 
    result.write(oprot)
6053 
    oprot.writeMessageEnd()
6054 
    oprot.trans.flush()
3956 chandransh 6055 
 
4008 mandeep.dh 6056 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
6057 
    args = markTransactionAsProcessed_args()
6058 
    args.read(iprot)
6059 
    iprot.readMessageEnd()
6060 
    result = markTransactionAsProcessed_result()
6061 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
6062 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
6063 
    result.write(oprot)
6064 
    oprot.writeMessageEnd()
6065 
    oprot.trans.flush()
6066 
 
4018 chandransh 6067 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
6068 
    args = getItemWiseRiskyOrdersCount_args()
6069 
    args.read(iprot)
6070 
    iprot.readMessageEnd()
6071 
    result = getItemWiseRiskyOrdersCount_result()
6072 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
6073 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
6074 
    result.write(oprot)
6075 
    oprot.writeMessageEnd()
6076 
    oprot.trans.flush()
4008 mandeep.dh 6077 
 
4295 varun.gupt 6078 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
6079 
    args = getOrdersForItemIds_args()
6080 
    args.read(iprot)
6081 
    iprot.readMessageEnd()
6082 
    result = getOrdersForItemIds_result()
6083 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
6084 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
6085 
    result.write(oprot)
6086 
    oprot.writeMessageEnd()
6087 
    oprot.trans.flush()
6088 
 
4247 rajveer 6089 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
6090 
    args = markOrderCancellationRequestReceived_args()
6091 
    args.read(iprot)
6092 
    iprot.readMessageEnd()
6093 
    result = markOrderCancellationRequestReceived_result()
6094 
    try:
6095 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
6096 
    except TransactionServiceException, ex:
6097 
      result.ex = ex
6098 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
6099 
    result.write(oprot)
6100 
    oprot.writeMessageEnd()
6101 
    oprot.trans.flush()
4018 chandransh 6102 
 
4247 rajveer 6103 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
6104 
    args = markOrderCancellationRequestConfirmed_args()
6105 
    args.read(iprot)
6106 
    iprot.readMessageEnd()
6107 
    result = markOrderCancellationRequestConfirmed_result()
6108 
    try:
6109 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
6110 
    except TransactionServiceException, ex:
6111 
      result.ex = ex
6112 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
6113 
    result.write(oprot)
6114 
    oprot.writeMessageEnd()
6115 
    oprot.trans.flush()
6116 
 
6117 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
6118 
    args = markOrderCancellationRequestDenied_args()
6119 
    args.read(iprot)
6120 
    iprot.readMessageEnd()
6121 
    result = markOrderCancellationRequestDenied_result()
6122 
    try:
6123 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
6124 
    except TransactionServiceException, ex:
6125 
      result.ex = ex
6126 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
6127 
    result.write(oprot)
6128 
    oprot.writeMessageEnd()
6129 
    oprot.trans.flush()
6130 
 
4258 rajveer 6131 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
6132 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 6133 
    args.read(iprot)
6134 
    iprot.readMessageEnd()
4258 rajveer 6135 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 6136 
    try:
4258 rajveer 6137 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 6138 
    except TransactionServiceException, ex:
6139 
      result.ex = ex
4258 rajveer 6140 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 6141 
    result.write(oprot)
6142 
    oprot.writeMessageEnd()
6143 
    oprot.trans.flush()
6144 
 
4259 anupam.sin 6145 
  def process_refundTransaction(self, seqid, iprot, oprot):
6146 
    args = refundTransaction_args()
6147 
    args.read(iprot)
6148 
    iprot.readMessageEnd()
6149 
    result = refundTransaction_result()
6150 
    try:
6151 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
6152 
    except TransactionServiceException, ex:
6153 
      result.ex = ex
6154 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
6155 
    result.write(oprot)
6156 
    oprot.writeMessageEnd()
6157 
    oprot.trans.flush()
4247 rajveer 6158 
 
4324 mandeep.dh 6159 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
6160 
    args = updateShipmentAddress_args()
6161 
    args.read(iprot)
6162 
    iprot.readMessageEnd()
6163 
    result = updateShipmentAddress_result()
6164 
    try:
6165 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
6166 
    except TransactionServiceException, ex:
6167 
      result.ex = ex
6168 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
6169 
    result.write(oprot)
6170 
    oprot.writeMessageEnd()
6171 
    oprot.trans.flush()
6172 
 
4285 rajveer 6173 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
6174 
    args = acceptOrdersForItemId_args()
6175 
    args.read(iprot)
6176 
    iprot.readMessageEnd()
6177 
    result = acceptOrdersForItemId_result()
6178 
    try:
6179 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
6180 
    except TransactionServiceException, ex:
6181 
      result.ex = ex
6182 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
6183 
    result.write(oprot)
6184 
    oprot.writeMessageEnd()
6185 
    oprot.trans.flush()
4259 anupam.sin 6186 
 
4303 rajveer 6187 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
6188 
    args = markOrdersAsPORaised_args()
6189 
    args.read(iprot)
6190 
    iprot.readMessageEnd()
6191 
    result = markOrdersAsPORaised_result()
6192 
    try:
4369 rajveer 6193 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6194 
    except TransactionServiceException, ex:
6195 
      result.ex = ex
6196 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
6197 
    result.write(oprot)
6198 
    oprot.writeMessageEnd()
6199 
    oprot.trans.flush()
4285 rajveer 6200 
 
4303 rajveer 6201 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
6202 
    args = markOrdersAsReversalInitiated_args()
6203 
    args.read(iprot)
6204 
    iprot.readMessageEnd()
6205 
    result = markOrdersAsReversalInitiated_result()
6206 
    try:
4369 rajveer 6207 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6208 
    except TransactionServiceException, ex:
6209 
      result.ex = ex
6210 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
6211 
    result.write(oprot)
6212 
    oprot.writeMessageEnd()
6213 
    oprot.trans.flush()
6214 
 
6215 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
6216 
    args = markOrdersAsNotAvailabke_args()
6217 
    args.read(iprot)
6218 
    iprot.readMessageEnd()
6219 
    result = markOrdersAsNotAvailabke_result()
6220 
    try:
4369 rajveer 6221 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6222 
    except TransactionServiceException, ex:
6223 
      result.ex = ex
6224 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
6225 
    result.write(oprot)
6226 
    oprot.writeMessageEnd()
6227 
    oprot.trans.flush()
6228 
 
4369 rajveer 6229 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
6230 
    args = markOrdersAsTimeout_args()
6231 
    args.read(iprot)
6232 
    iprot.readMessageEnd()
6233 
    result = markOrdersAsTimeout_result()
6234 
    try:
6235 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
6236 
    except TransactionServiceException, ex:
6237 
      result.ex = ex
6238 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
6239 
    result.write(oprot)
6240 
    oprot.writeMessageEnd()
6241 
    oprot.trans.flush()
4303 rajveer 6242 
 
4662 rajveer 6243 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
6244 
    args = markOrderAsLostInTransit_args()
6245 
    args.read(iprot)
6246 
    iprot.readMessageEnd()
6247 
    result = markOrderAsLostInTransit_result()
6248 
    try:
6249 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
6250 
    except TransactionServiceException, ex:
6251 
      result.ex = ex
6252 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
6253 
    result.write(oprot)
6254 
    oprot.writeMessageEnd()
6255 
    oprot.trans.flush()
6256 
 
4386 anupam.sin 6257 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
6258 
    args = getOrderForAwb_args()
6259 
    args.read(iprot)
6260 
    iprot.readMessageEnd()
6261 
    result = getOrderForAwb_result()
6262 
    try:
6263 
      result.success = self._handler.getOrderForAwb(args.awb)
6264 
    except TransactionServiceException, ex:
6265 
      result.ex = ex
6266 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
6267 
    result.write(oprot)
6268 
    oprot.writeMessageEnd()
6269 
    oprot.trans.flush()
4369 rajveer 6270 
 
4506 phani.kuma 6271 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
6272 
    args = getOrdersForProviderForStatus_args()
6273 
    args.read(iprot)
6274 
    iprot.readMessageEnd()
6275 
    result = getOrdersForProviderForStatus_result()
6276 
    try:
4910 phani.kuma 6277 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 6278 
    except TransactionServiceException, ex:
6279 
      result.ex = ex
6280 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
6281 
    result.write(oprot)
6282 
    oprot.writeMessageEnd()
6283 
    oprot.trans.flush()
4386 anupam.sin 6284 
 
4600 varun.gupt 6285 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
6286 
    args = getBilledOrdersForVendor_args()
6287 
    args.read(iprot)
6288 
    iprot.readMessageEnd()
6289 
    result = getBilledOrdersForVendor_result()
6290 
    try:
6291 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
6292 
    except TransactionServiceException, ex:
6293 
      result.ex = ex
6294 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
6295 
    result.write(oprot)
6296 
    oprot.writeMessageEnd()
6297 
    oprot.trans.flush()
4506 phani.kuma 6298 
 
4607 rajveer 6299 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
6300 
    args = getSlippedSippingDateOrders_args()
6301 
    args.read(iprot)
6302 
    iprot.readMessageEnd()
6303 
    result = getSlippedSippingDateOrders_result()
6304 
    try:
6305 
      result.success = self._handler.getSlippedSippingDateOrders()
6306 
    except TransactionServiceException, ex:
6307 
      result.ex = ex
6308 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
6309 
    result.write(oprot)
6310 
    oprot.writeMessageEnd()
6311 
    oprot.trans.flush()
6312 
 
4709 rajveer 6313 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
6314 
    args = getCancelledOrders_args()
6315 
    args.read(iprot)
6316 
    iprot.readMessageEnd()
6317 
    result = getCancelledOrders_result()
6318 
    try:
6319 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
6320 
    except TransactionServiceException, ex:
6321 
      result.ex = ex
6322 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
6323 
    result.write(oprot)
6324 
    oprot.writeMessageEnd()
6325 
    oprot.trans.flush()
6326 
 
4600 varun.gupt 6327 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
6328 
    args = saveBluedartSettlements_args()
6329 
    args.read(iprot)
6330 
    iprot.readMessageEnd()
6331 
    result = saveBluedartSettlements_result()
6332 
    try:
6333 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
6334 
    except TransactionServiceException, ex:
6335 
      result.ex = ex
6336 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
6337 
    result.write(oprot)
6338 
    oprot.writeMessageEnd()
6339 
    oprot.trans.flush()
6340 
 
6341 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
6342 
    args = savePaymentSettlements_args()
6343 
    args.read(iprot)
6344 
    iprot.readMessageEnd()
6345 
    result = savePaymentSettlements_result()
6346 
    try:
4905 varun.gupt 6347 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 6348 
    except TransactionServiceException, ex:
6349 
      result.ex = ex
6350 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
6351 
    result.write(oprot)
6352 
    oprot.writeMessageEnd()
6353 
    oprot.trans.flush()
6354 
 
6355 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
6356 
    args = saveEBSSettlementSummary_args()
6357 
    args.read(iprot)
6358 
    iprot.readMessageEnd()
6359 
    result = saveEBSSettlementSummary_result()
6360 
    try:
6361 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
6362 
    except TransactionServiceException, ex:
6363 
      result.ex = ex
6364 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
6365 
    result.write(oprot)
6366 
    oprot.writeMessageEnd()
6367 
    oprot.trans.flush()
6368 
 
6369 
  def process_getSettlementForPaymentId(self, seqid, iprot, oprot):
6370 
    args = getSettlementForPaymentId_args()
6371 
    args.read(iprot)
6372 
    iprot.readMessageEnd()
6373 
    result = getSettlementForPaymentId_result()
6374 
    try:
6375 
      result.success = self._handler.getSettlementForPaymentId(args.paymentId)
6376 
    except TransactionServiceException, ex:
6377 
      result.ex = ex
6378 
    oprot.writeMessageBegin("getSettlementForPaymentId", TMessageType.REPLY, seqid)
6379 
    result.write(oprot)
6380 
    oprot.writeMessageEnd()
6381 
    oprot.trans.flush()
6382 
 
6383 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
6384 
    args = getEBSSettlementSummaries_args()
6385 
    args.read(iprot)
6386 
    iprot.readMessageEnd()
6387 
    result = getEBSSettlementSummaries_result()
6388 
    try:
6389 
      result.success = self._handler.getEBSSettlementSummaries()
6390 
    except TransactionServiceException, ex:
6391 
      result.ex = ex
6392 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
6393 
    result.write(oprot)
6394 
    oprot.writeMessageEnd()
6395 
    oprot.trans.flush()
6396 
 
6397 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
6398 
    args = markEBSSettlementUploaded_args()
6399 
    args.read(iprot)
6400 
    iprot.readMessageEnd()
6401 
    result = markEBSSettlementUploaded_result()
6402 
    try:
6403 
      self._handler.markEBSSettlementUploaded(args.settlementId)
6404 
    except TransactionServiceException, ex:
6405 
      result.ex = ex
6406 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
6407 
    result.write(oprot)
6408 
    oprot.writeMessageEnd()
6409 
    oprot.trans.flush()
6410 
 
6411 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
6412 
    args = getEBSSettlementDate_args()
6413 
    args.read(iprot)
6414 
    iprot.readMessageEnd()
6415 
    result = getEBSSettlementDate_result()
6416 
    try:
6417 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
6418 
    except TransactionServiceException, ex:
6419 
      result.ex = ex
6420 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
6421 
    result.write(oprot)
6422 
    oprot.writeMessageEnd()
6423 
    oprot.trans.flush()
6424 
 
4715 varun.gupt 6425 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
6426 
    args = getSettlementsByDate_args()
6427 
    args.read(iprot)
6428 
    iprot.readMessageEnd()
6429 
    result = getSettlementsByDate_result()
6430 
    try:
6431 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
6432 
    except TransactionServiceException, ex:
6433 
      result.ex = ex
6434 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
6435 
    result.write(oprot)
6436 
    oprot.writeMessageEnd()
6437 
    oprot.trans.flush()
4600 varun.gupt 6438 
 
4715 varun.gupt 6439 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
6440 
    args = getReshippedOrderIds_args()
6441 
    args.read(iprot)
6442 
    iprot.readMessageEnd()
6443 
    result = getReshippedOrderIds_result()
6444 
    try:
6445 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
6446 
    except TransactionServiceException, ex:
6447 
      result.ex = ex
6448 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
6449 
    result.write(oprot)
6450 
    oprot.writeMessageEnd()
6451 
    oprot.trans.flush()
6452 
 
4757 mandeep.dh 6453 
  def process_updateOrdersAsPORaised(self, seqid, iprot, oprot):
6454 
    args = updateOrdersAsPORaised_args()
6455 
    args.read(iprot)
6456 
    iprot.readMessageEnd()
6457 
    result = updateOrdersAsPORaised_result()
6458 
    try:
6459 
      self._handler.updateOrdersAsPORaised(args.itemIdQuantityMap, args.purchaseOrderId, args.warehouseId)
6460 
    except TransactionServiceException, ex:
6461 
      result.ex = ex
6462 
    oprot.writeMessageBegin("updateOrdersAsPORaised", TMessageType.REPLY, seqid)
6463 
    result.write(oprot)
6464 
    oprot.writeMessageEnd()
6465 
    oprot.trans.flush()
4715 varun.gupt 6466 
 
4875 varun.gupt 6467 
  def process_getOrdersWhereVendorNotPaid(self, seqid, iprot, oprot):
6468 
    args = getOrdersWhereVendorNotPaid_args()
6469 
    args.read(iprot)
6470 
    iprot.readMessageEnd()
6471 
    result = getOrdersWhereVendorNotPaid_result()
6472 
    try:
6473 
      result.success = self._handler.getOrdersWhereVendorNotPaid(args.vendorId)
6474 
    except TransactionServiceException, ex:
6475 
      result.ex = ex
6476 
    oprot.writeMessageBegin("getOrdersWhereVendorNotPaid", TMessageType.REPLY, seqid)
6477 
    result.write(oprot)
6478 
    oprot.writeMessageEnd()
6479 
    oprot.trans.flush()
4757 mandeep.dh 6480 
 
5031 varun.gupt 6481 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
6482 
    args = getStatusDistributionOfOrders_args()
6483 
    args.read(iprot)
6484 
    iprot.readMessageEnd()
6485 
    result = getStatusDistributionOfOrders_result()
6486 
    try:
6487 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
6488 
    except TransactionServiceException, ex:
6489 
      result.ex = ex
6490 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
6491 
    result.write(oprot)
6492 
    oprot.writeMessageEnd()
6493 
    oprot.trans.flush()
4875 varun.gupt 6494 
 
5067 varun.gupt 6495 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
6496 
    args = getOrderIdsForStatus_args()
6497 
    args.read(iprot)
6498 
    iprot.readMessageEnd()
6499 
    result = getOrderIdsForStatus_result()
6500 
    try:
6501 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
6502 
    except TransactionServiceException, ex:
6503 
      result.ex = ex
6504 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
6505 
    result.write(oprot)
6506 
    oprot.writeMessageEnd()
6507 
    oprot.trans.flush()
5031 varun.gupt 6508 
 
5067 varun.gupt 6509 
 
94 ashish 6510 
# HELPER FUNCTIONS AND STRUCTURES
6511 
 
6512 
class createTransaction_args:
6513 
  """
6514 
  Attributes:
6515 
   - transaction
6516 
  """
6517 
 
6518 
  thrift_spec = (
6519 
    None, # 0
6520 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
6521 
  )
6522 
 
6523 
  def __init__(self, transaction=None,):
6524 
    self.transaction = transaction
6525 
 
6526 
  def read(self, iprot):
6527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6529 
      return
6530 
    iprot.readStructBegin()
6531 
    while True:
6532 
      (fname, ftype, fid) = iprot.readFieldBegin()
6533 
      if ftype == TType.STOP:
6534 
        break
6535 
      if fid == 1:
6536 
        if ftype == TType.STRUCT:
6537 
          self.transaction = Transaction()
6538 
          self.transaction.read(iprot)
6539 
        else:
6540 
          iprot.skip(ftype)
6541 
      else:
6542 
        iprot.skip(ftype)
6543 
      iprot.readFieldEnd()
6544 
    iprot.readStructEnd()
6545 
 
6546 
  def write(self, oprot):
6547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6549 
      return
6550 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 6551 
    if self.transaction is not None:
94 ashish 6552 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
6553 
      self.transaction.write(oprot)
6554 
      oprot.writeFieldEnd()
6555 
    oprot.writeFieldStop()
6556 
    oprot.writeStructEnd()
6557 
 
3431 rajveer 6558 
  def validate(self):
6559 
    return
6560 
 
6561 
 
94 ashish 6562 
  def __repr__(self):
6563 
    L = ['%s=%r' % (key, value)
6564 
      for key, value in self.__dict__.iteritems()]
6565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6566 
 
6567 
  def __eq__(self, other):
6568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6569 
 
6570 
  def __ne__(self, other):
6571 
    return not (self == other)
6572 
 
6573 
class createTransaction_result:
6574 
  """
6575 
  Attributes:
132 ashish 6576 
   - success
94 ashish 6577 
   - ex
6578 
  """
6579 
 
6580 
  thrift_spec = (
132 ashish 6581 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 6582 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6583 
  )
6584 
 
132 ashish 6585 
  def __init__(self, success=None, ex=None,):
6586 
    self.success = success
94 ashish 6587 
    self.ex = ex
6588 
 
6589 
  def read(self, iprot):
6590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6592 
      return
6593 
    iprot.readStructBegin()
6594 
    while True:
6595 
      (fname, ftype, fid) = iprot.readFieldBegin()
6596 
      if ftype == TType.STOP:
6597 
        break
132 ashish 6598 
      if fid == 0:
6599 
        if ftype == TType.I64:
6600 
          self.success = iprot.readI64();
6601 
        else:
6602 
          iprot.skip(ftype)
6603 
      elif fid == 1:
94 ashish 6604 
        if ftype == TType.STRUCT:
6605 
          self.ex = TransactionServiceException()
6606 
          self.ex.read(iprot)
6607 
        else:
6608 
          iprot.skip(ftype)
6609 
      else:
6610 
        iprot.skip(ftype)
6611 
      iprot.readFieldEnd()
6612 
    iprot.readStructEnd()
6613 
 
6614 
  def write(self, oprot):
6615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6617 
      return
6618 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 6619 
    if self.success is not None:
132 ashish 6620 
      oprot.writeFieldBegin('success', TType.I64, 0)
6621 
      oprot.writeI64(self.success)
6622 
      oprot.writeFieldEnd()
3431 rajveer 6623 
    if self.ex is not None:
94 ashish 6624 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6625 
      self.ex.write(oprot)
6626 
      oprot.writeFieldEnd()
6627 
    oprot.writeFieldStop()
6628 
    oprot.writeStructEnd()
6629 
 
3431 rajveer 6630 
  def validate(self):
6631 
    return
6632 
 
6633 
 
94 ashish 6634 
  def __repr__(self):
6635 
    L = ['%s=%r' % (key, value)
6636 
      for key, value in self.__dict__.iteritems()]
6637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6638 
 
6639 
  def __eq__(self, other):
6640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6641 
 
6642 
  def __ne__(self, other):
6643 
    return not (self == other)
6644 
 
6645 
class getTransaction_args:
6646 
  """
6647 
  Attributes:
6648 
   - id
6649 
  """
6650 
 
6651 
  thrift_spec = (
6652 
    None, # 0
6653 
    (1, TType.I64, 'id', None, None, ), # 1
6654 
  )
6655 
 
6656 
  def __init__(self, id=None,):
6657 
    self.id = id
6658 
 
6659 
  def read(self, iprot):
6660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6662 
      return
6663 
    iprot.readStructBegin()
6664 
    while True:
6665 
      (fname, ftype, fid) = iprot.readFieldBegin()
6666 
      if ftype == TType.STOP:
6667 
        break
6668 
      if fid == 1:
6669 
        if ftype == TType.I64:
6670 
          self.id = iprot.readI64();
6671 
        else:
6672 
          iprot.skip(ftype)
6673 
      else:
6674 
        iprot.skip(ftype)
6675 
      iprot.readFieldEnd()
6676 
    iprot.readStructEnd()
6677 
 
6678 
  def write(self, oprot):
6679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6681 
      return
6682 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 6683 
    if self.id is not None:
94 ashish 6684 
      oprot.writeFieldBegin('id', TType.I64, 1)
6685 
      oprot.writeI64(self.id)
6686 
      oprot.writeFieldEnd()
6687 
    oprot.writeFieldStop()
6688 
    oprot.writeStructEnd()
6689 
 
3431 rajveer 6690 
  def validate(self):
6691 
    return
6692 
 
6693 
 
94 ashish 6694 
  def __repr__(self):
6695 
    L = ['%s=%r' % (key, value)
6696 
      for key, value in self.__dict__.iteritems()]
6697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6698 
 
6699 
  def __eq__(self, other):
6700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6701 
 
6702 
  def __ne__(self, other):
6703 
    return not (self == other)
6704 
 
6705 
class getTransaction_result:
6706 
  """
6707 
  Attributes:
6708 
   - success
6709 
   - ex
6710 
  """
6711 
 
6712 
  thrift_spec = (
6713 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
6714 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6715 
  )
6716 
 
6717 
  def __init__(self, success=None, ex=None,):
6718 
    self.success = success
6719 
    self.ex = ex
6720 
 
6721 
  def read(self, iprot):
6722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6724 
      return
6725 
    iprot.readStructBegin()
6726 
    while True:
6727 
      (fname, ftype, fid) = iprot.readFieldBegin()
6728 
      if ftype == TType.STOP:
6729 
        break
6730 
      if fid == 0:
6731 
        if ftype == TType.STRUCT:
6732 
          self.success = Transaction()
6733 
          self.success.read(iprot)
6734 
        else:
6735 
          iprot.skip(ftype)
6736 
      elif fid == 1:
6737 
        if ftype == TType.STRUCT:
6738 
          self.ex = TransactionServiceException()
6739 
          self.ex.read(iprot)
6740 
        else:
6741 
          iprot.skip(ftype)
6742 
      else:
6743 
        iprot.skip(ftype)
6744 
      iprot.readFieldEnd()
6745 
    iprot.readStructEnd()
6746 
 
6747 
  def write(self, oprot):
6748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6750 
      return
6751 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 6752 
    if self.success is not None:
94 ashish 6753 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6754 
      self.success.write(oprot)
6755 
      oprot.writeFieldEnd()
3431 rajveer 6756 
    if self.ex is not None:
94 ashish 6757 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6758 
      self.ex.write(oprot)
6759 
      oprot.writeFieldEnd()
6760 
    oprot.writeFieldStop()
6761 
    oprot.writeStructEnd()
6762 
 
3431 rajveer 6763 
  def validate(self):
6764 
    return
6765 
 
6766 
 
94 ashish 6767 
  def __repr__(self):
6768 
    L = ['%s=%r' % (key, value)
6769 
      for key, value in self.__dict__.iteritems()]
6770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6771 
 
6772 
  def __eq__(self, other):
6773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6774 
 
6775 
  def __ne__(self, other):
6776 
    return not (self == other)
6777 
 
6778 
class getTransactionsForCustomer_args:
6779 
  """
6780 
  Attributes:
6781 
   - customerId
6782 
   - from_date
6783 
   - to_date
6784 
   - status
6785 
  """
6786 
 
6787 
  thrift_spec = (
6788 
    None, # 0
6789 
    (1, TType.I64, 'customerId', None, None, ), # 1
6790 
    (2, TType.I64, 'from_date', None, None, ), # 2
6791 
    (3, TType.I64, 'to_date', None, None, ), # 3
6792 
    (4, TType.I32, 'status', None, None, ), # 4
6793 
  )
6794 
 
6795 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
6796 
    self.customerId = customerId
6797 
    self.from_date = from_date
6798 
    self.to_date = to_date
6799 
    self.status = status
6800 
 
6801 
  def read(self, iprot):
6802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6804 
      return
6805 
    iprot.readStructBegin()
6806 
    while True:
6807 
      (fname, ftype, fid) = iprot.readFieldBegin()
6808 
      if ftype == TType.STOP:
6809 
        break
6810 
      if fid == 1:
6811 
        if ftype == TType.I64:
6812 
          self.customerId = iprot.readI64();
6813 
        else:
6814 
          iprot.skip(ftype)
6815 
      elif fid == 2:
6816 
        if ftype == TType.I64:
6817 
          self.from_date = iprot.readI64();
6818 
        else:
6819 
          iprot.skip(ftype)
6820 
      elif fid == 3:
6821 
        if ftype == TType.I64:
6822 
          self.to_date = iprot.readI64();
6823 
        else:
6824 
          iprot.skip(ftype)
6825 
      elif fid == 4:
6826 
        if ftype == TType.I32:
6827 
          self.status = iprot.readI32();
6828 
        else:
6829 
          iprot.skip(ftype)
6830 
      else:
6831 
        iprot.skip(ftype)
6832 
      iprot.readFieldEnd()
6833 
    iprot.readStructEnd()
6834 
 
6835 
  def write(self, oprot):
6836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6838 
      return
6839 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 6840 
    if self.customerId is not None:
94 ashish 6841 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6842 
      oprot.writeI64(self.customerId)
6843 
      oprot.writeFieldEnd()
3431 rajveer 6844 
    if self.from_date is not None:
94 ashish 6845 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6846 
      oprot.writeI64(self.from_date)
6847 
      oprot.writeFieldEnd()
3431 rajveer 6848 
    if self.to_date is not None:
94 ashish 6849 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6850 
      oprot.writeI64(self.to_date)
6851 
      oprot.writeFieldEnd()
3431 rajveer 6852 
    if self.status is not None:
94 ashish 6853 
      oprot.writeFieldBegin('status', TType.I32, 4)
6854 
      oprot.writeI32(self.status)
6855 
      oprot.writeFieldEnd()
6856 
    oprot.writeFieldStop()
6857 
    oprot.writeStructEnd()
6858 
 
3431 rajveer 6859 
  def validate(self):
6860 
    return
6861 
 
6862 
 
94 ashish 6863 
  def __repr__(self):
6864 
    L = ['%s=%r' % (key, value)
6865 
      for key, value in self.__dict__.iteritems()]
6866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6867 
 
6868 
  def __eq__(self, other):
6869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6870 
 
6871 
  def __ne__(self, other):
6872 
    return not (self == other)
6873 
 
6874 
class getTransactionsForCustomer_result:
6875 
  """
6876 
  Attributes:
6877 
   - success
6878 
   - ex
6879 
  """
6880 
 
6881 
  thrift_spec = (
6882 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6883 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6884 
  )
6885 
 
6886 
  def __init__(self, success=None, ex=None,):
6887 
    self.success = success
6888 
    self.ex = ex
6889 
 
6890 
  def read(self, iprot):
6891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6893 
      return
6894 
    iprot.readStructBegin()
6895 
    while True:
6896 
      (fname, ftype, fid) = iprot.readFieldBegin()
6897 
      if ftype == TType.STOP:
6898 
        break
6899 
      if fid == 0:
6900 
        if ftype == TType.LIST:
6901 
          self.success = []
5031 varun.gupt 6902 
          (_etype66, _size63) = iprot.readListBegin()
6903 
          for _i67 in xrange(_size63):
6904 
            _elem68 = Transaction()
6905 
            _elem68.read(iprot)
6906 
            self.success.append(_elem68)
94 ashish 6907 
          iprot.readListEnd()
6908 
        else:
6909 
          iprot.skip(ftype)
6910 
      elif fid == 1:
6911 
        if ftype == TType.STRUCT:
6912 
          self.ex = TransactionServiceException()
6913 
          self.ex.read(iprot)
6914 
        else:
6915 
          iprot.skip(ftype)
6916 
      else:
6917 
        iprot.skip(ftype)
6918 
      iprot.readFieldEnd()
6919 
    iprot.readStructEnd()
6920 
 
6921 
  def write(self, oprot):
6922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6924 
      return
6925 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 6926 
    if self.success is not None:
94 ashish 6927 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6928 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 6929 
      for iter69 in self.success:
6930 
        iter69.write(oprot)
94 ashish 6931 
      oprot.writeListEnd()
6932 
      oprot.writeFieldEnd()
3431 rajveer 6933 
    if self.ex is not None:
94 ashish 6934 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6935 
      self.ex.write(oprot)
6936 
      oprot.writeFieldEnd()
6937 
    oprot.writeFieldStop()
6938 
    oprot.writeStructEnd()
6939 
 
3431 rajveer 6940 
  def validate(self):
6941 
    return
6942 
 
6943 
 
94 ashish 6944 
  def __repr__(self):
6945 
    L = ['%s=%r' % (key, value)
6946 
      for key, value in self.__dict__.iteritems()]
6947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6948 
 
6949 
  def __eq__(self, other):
6950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6951 
 
6952 
  def __ne__(self, other):
6953 
    return not (self == other)
6954 
 
132 ashish 6955 
class getTransactionsForShoppingCartId_args:
6956 
  """
6957 
  Attributes:
6958 
   - shoppingCartId
6959 
  """
6960 
 
6961 
  thrift_spec = (
6962 
    None, # 0
6963 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
6964 
  )
6965 
 
6966 
  def __init__(self, shoppingCartId=None,):
6967 
    self.shoppingCartId = shoppingCartId
6968 
 
6969 
  def read(self, iprot):
6970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6972 
      return
6973 
    iprot.readStructBegin()
6974 
    while True:
6975 
      (fname, ftype, fid) = iprot.readFieldBegin()
6976 
      if ftype == TType.STOP:
6977 
        break
6978 
      if fid == 1:
6979 
        if ftype == TType.I64:
6980 
          self.shoppingCartId = iprot.readI64();
6981 
        else:
6982 
          iprot.skip(ftype)
6983 
      else:
6984 
        iprot.skip(ftype)
6985 
      iprot.readFieldEnd()
6986 
    iprot.readStructEnd()
6987 
 
6988 
  def write(self, oprot):
6989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6991 
      return
6992 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 6993 
    if self.shoppingCartId is not None:
132 ashish 6994 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
6995 
      oprot.writeI64(self.shoppingCartId)
6996 
      oprot.writeFieldEnd()
6997 
    oprot.writeFieldStop()
6998 
    oprot.writeStructEnd()
6999 
 
3431 rajveer 7000 
  def validate(self):
7001 
    return
7002 
 
7003 
 
132 ashish 7004 
  def __repr__(self):
7005 
    L = ['%s=%r' % (key, value)
7006 
      for key, value in self.__dict__.iteritems()]
7007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7008 
 
7009 
  def __eq__(self, other):
7010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7011 
 
7012 
  def __ne__(self, other):
7013 
    return not (self == other)
7014 
 
7015 
class getTransactionsForShoppingCartId_result:
7016 
  """
7017 
  Attributes:
7018 
   - success
7019 
   - ex
7020 
  """
7021 
 
7022 
  thrift_spec = (
7023 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7024 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7025 
  )
7026 
 
7027 
  def __init__(self, success=None, ex=None,):
7028 
    self.success = success
7029 
    self.ex = ex
7030 
 
7031 
  def read(self, iprot):
7032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7034 
      return
7035 
    iprot.readStructBegin()
7036 
    while True:
7037 
      (fname, ftype, fid) = iprot.readFieldBegin()
7038 
      if ftype == TType.STOP:
7039 
        break
7040 
      if fid == 0:
7041 
        if ftype == TType.LIST:
7042 
          self.success = []
5031 varun.gupt 7043 
          (_etype73, _size70) = iprot.readListBegin()
7044 
          for _i74 in xrange(_size70):
7045 
            _elem75 = Transaction()
7046 
            _elem75.read(iprot)
7047 
            self.success.append(_elem75)
132 ashish 7048 
          iprot.readListEnd()
7049 
        else:
7050 
          iprot.skip(ftype)
7051 
      elif fid == 1:
7052 
        if ftype == TType.STRUCT:
7053 
          self.ex = TransactionServiceException()
7054 
          self.ex.read(iprot)
7055 
        else:
7056 
          iprot.skip(ftype)
7057 
      else:
7058 
        iprot.skip(ftype)
7059 
      iprot.readFieldEnd()
7060 
    iprot.readStructEnd()
7061 
 
7062 
  def write(self, oprot):
7063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7065 
      return
7066 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 7067 
    if self.success is not None:
132 ashish 7068 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7069 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7070 
      for iter76 in self.success:
7071 
        iter76.write(oprot)
132 ashish 7072 
      oprot.writeListEnd()
7073 
      oprot.writeFieldEnd()
3431 rajveer 7074 
    if self.ex is not None:
132 ashish 7075 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7076 
      self.ex.write(oprot)
7077 
      oprot.writeFieldEnd()
7078 
    oprot.writeFieldStop()
7079 
    oprot.writeStructEnd()
7080 
 
3431 rajveer 7081 
  def validate(self):
7082 
    return
7083 
 
7084 
 
132 ashish 7085 
  def __repr__(self):
7086 
    L = ['%s=%r' % (key, value)
7087 
      for key, value in self.__dict__.iteritems()]
7088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7089 
 
7090 
  def __eq__(self, other):
7091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7092 
 
7093 
  def __ne__(self, other):
7094 
    return not (self == other)
7095 
 
94 ashish 7096 
class getTransactionStatus_args:
7097 
  """
7098 
  Attributes:
7099 
   - transactionId
7100 
  """
7101 
 
7102 
  thrift_spec = (
7103 
    None, # 0
7104 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7105 
  )
7106 
 
7107 
  def __init__(self, transactionId=None,):
7108 
    self.transactionId = transactionId
7109 
 
7110 
  def read(self, iprot):
7111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7113 
      return
7114 
    iprot.readStructBegin()
7115 
    while True:
7116 
      (fname, ftype, fid) = iprot.readFieldBegin()
7117 
      if ftype == TType.STOP:
7118 
        break
7119 
      if fid == 1:
7120 
        if ftype == TType.I64:
7121 
          self.transactionId = iprot.readI64();
7122 
        else:
7123 
          iprot.skip(ftype)
7124 
      else:
7125 
        iprot.skip(ftype)
7126 
      iprot.readFieldEnd()
7127 
    iprot.readStructEnd()
7128 
 
7129 
  def write(self, oprot):
7130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7132 
      return
7133 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 7134 
    if self.transactionId is not None:
94 ashish 7135 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7136 
      oprot.writeI64(self.transactionId)
7137 
      oprot.writeFieldEnd()
7138 
    oprot.writeFieldStop()
7139 
    oprot.writeStructEnd()
7140 
 
3431 rajveer 7141 
  def validate(self):
7142 
    return
7143 
 
7144 
 
94 ashish 7145 
  def __repr__(self):
7146 
    L = ['%s=%r' % (key, value)
7147 
      for key, value in self.__dict__.iteritems()]
7148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7149 
 
7150 
  def __eq__(self, other):
7151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7152 
 
7153 
  def __ne__(self, other):
7154 
    return not (self == other)
7155 
 
7156 
class getTransactionStatus_result:
7157 
  """
7158 
  Attributes:
7159 
   - success
7160 
   - ex
7161 
  """
7162 
 
7163 
  thrift_spec = (
7164 
    (0, TType.I32, 'success', None, None, ), # 0
7165 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7166 
  )
7167 
 
7168 
  def __init__(self, success=None, ex=None,):
7169 
    self.success = success
7170 
    self.ex = ex
7171 
 
7172 
  def read(self, iprot):
7173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7175 
      return
7176 
    iprot.readStructBegin()
7177 
    while True:
7178 
      (fname, ftype, fid) = iprot.readFieldBegin()
7179 
      if ftype == TType.STOP:
7180 
        break
7181 
      if fid == 0:
7182 
        if ftype == TType.I32:
7183 
          self.success = iprot.readI32();
7184 
        else:
7185 
          iprot.skip(ftype)
7186 
      elif fid == 1:
7187 
        if ftype == TType.STRUCT:
7188 
          self.ex = TransactionServiceException()
7189 
          self.ex.read(iprot)
7190 
        else:
7191 
          iprot.skip(ftype)
7192 
      else:
7193 
        iprot.skip(ftype)
7194 
      iprot.readFieldEnd()
7195 
    iprot.readStructEnd()
7196 
 
7197 
  def write(self, oprot):
7198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7200 
      return
7201 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 7202 
    if self.success is not None:
94 ashish 7203 
      oprot.writeFieldBegin('success', TType.I32, 0)
7204 
      oprot.writeI32(self.success)
7205 
      oprot.writeFieldEnd()
3431 rajveer 7206 
    if self.ex is not None:
94 ashish 7207 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7208 
      self.ex.write(oprot)
7209 
      oprot.writeFieldEnd()
7210 
    oprot.writeFieldStop()
7211 
    oprot.writeStructEnd()
7212 
 
3431 rajveer 7213 
  def validate(self):
7214 
    return
7215 
 
7216 
 
94 ashish 7217 
  def __repr__(self):
7218 
    L = ['%s=%r' % (key, value)
7219 
      for key, value in self.__dict__.iteritems()]
7220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7221 
 
7222 
  def __eq__(self, other):
7223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7224 
 
7225 
  def __ne__(self, other):
7226 
    return not (self == other)
7227 
 
7228 
class changeTransactionStatus_args:
7229 
  """
7230 
  Attributes:
7231 
   - transactionId
7232 
   - status
7233 
   - description
7234 
  """
7235 
 
7236 
  thrift_spec = (
7237 
    None, # 0
7238 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7239 
    (2, TType.I32, 'status', None, None, ), # 2
7240 
    (3, TType.STRING, 'description', None, None, ), # 3
7241 
  )
7242 
 
7243 
  def __init__(self, transactionId=None, status=None, description=None,):
7244 
    self.transactionId = transactionId
7245 
    self.status = status
7246 
    self.description = description
7247 
 
7248 
  def read(self, iprot):
7249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7251 
      return
7252 
    iprot.readStructBegin()
7253 
    while True:
7254 
      (fname, ftype, fid) = iprot.readFieldBegin()
7255 
      if ftype == TType.STOP:
7256 
        break
7257 
      if fid == 1:
7258 
        if ftype == TType.I64:
7259 
          self.transactionId = iprot.readI64();
7260 
        else:
7261 
          iprot.skip(ftype)
7262 
      elif fid == 2:
7263 
        if ftype == TType.I32:
7264 
          self.status = iprot.readI32();
7265 
        else:
7266 
          iprot.skip(ftype)
7267 
      elif fid == 3:
7268 
        if ftype == TType.STRING:
7269 
          self.description = iprot.readString();
7270 
        else:
7271 
          iprot.skip(ftype)
7272 
      else:
7273 
        iprot.skip(ftype)
7274 
      iprot.readFieldEnd()
7275 
    iprot.readStructEnd()
7276 
 
7277 
  def write(self, oprot):
7278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7280 
      return
7281 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 7282 
    if self.transactionId is not None:
94 ashish 7283 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7284 
      oprot.writeI64(self.transactionId)
7285 
      oprot.writeFieldEnd()
3431 rajveer 7286 
    if self.status is not None:
94 ashish 7287 
      oprot.writeFieldBegin('status', TType.I32, 2)
7288 
      oprot.writeI32(self.status)
7289 
      oprot.writeFieldEnd()
3431 rajveer 7290 
    if self.description is not None:
94 ashish 7291 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7292 
      oprot.writeString(self.description)
7293 
      oprot.writeFieldEnd()
7294 
    oprot.writeFieldStop()
7295 
    oprot.writeStructEnd()
7296 
 
3431 rajveer 7297 
  def validate(self):
7298 
    return
7299 
 
7300 
 
94 ashish 7301 
  def __repr__(self):
7302 
    L = ['%s=%r' % (key, value)
7303 
      for key, value in self.__dict__.iteritems()]
7304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7305 
 
7306 
  def __eq__(self, other):
7307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7308 
 
7309 
  def __ne__(self, other):
7310 
    return not (self == other)
7311 
 
7312 
class changeTransactionStatus_result:
7313 
  """
7314 
  Attributes:
7315 
   - success
7316 
   - ex
7317 
  """
7318 
 
7319 
  thrift_spec = (
7320 
    (0, TType.BOOL, 'success', None, None, ), # 0
7321 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7322 
  )
7323 
 
7324 
  def __init__(self, success=None, ex=None,):
7325 
    self.success = success
7326 
    self.ex = ex
7327 
 
7328 
  def read(self, iprot):
7329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7331 
      return
7332 
    iprot.readStructBegin()
7333 
    while True:
7334 
      (fname, ftype, fid) = iprot.readFieldBegin()
7335 
      if ftype == TType.STOP:
7336 
        break
7337 
      if fid == 0:
7338 
        if ftype == TType.BOOL:
7339 
          self.success = iprot.readBool();
7340 
        else:
7341 
          iprot.skip(ftype)
7342 
      elif fid == 1:
7343 
        if ftype == TType.STRUCT:
7344 
          self.ex = TransactionServiceException()
7345 
          self.ex.read(iprot)
7346 
        else:
7347 
          iprot.skip(ftype)
7348 
      else:
7349 
        iprot.skip(ftype)
7350 
      iprot.readFieldEnd()
7351 
    iprot.readStructEnd()
7352 
 
7353 
  def write(self, oprot):
7354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7356 
      return
7357 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 7358 
    if self.success is not None:
94 ashish 7359 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7360 
      oprot.writeBool(self.success)
7361 
      oprot.writeFieldEnd()
3431 rajveer 7362 
    if self.ex is not None:
94 ashish 7363 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7364 
      self.ex.write(oprot)
7365 
      oprot.writeFieldEnd()
7366 
    oprot.writeFieldStop()
7367 
    oprot.writeStructEnd()
7368 
 
3431 rajveer 7369 
  def validate(self):
7370 
    return
7371 
 
7372 
 
94 ashish 7373 
  def __repr__(self):
7374 
    L = ['%s=%r' % (key, value)
7375 
      for key, value in self.__dict__.iteritems()]
7376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7377 
 
7378 
  def __eq__(self, other):
7379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7380 
 
7381 
  def __ne__(self, other):
7382 
    return not (self == other)
7383 
 
1398 varun.gupt 7384 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 7385 
  """
7386 
  Attributes:
7387 
   - transactionId
7388 
  """
7389 
 
7390 
  thrift_spec = (
7391 
    None, # 0
7392 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7393 
  )
7394 
 
7395 
  def __init__(self, transactionId=None,):
7396 
    self.transactionId = transactionId
7397 
 
7398 
  def read(self, iprot):
7399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7401 
      return
7402 
    iprot.readStructBegin()
7403 
    while True:
7404 
      (fname, ftype, fid) = iprot.readFieldBegin()
7405 
      if ftype == TType.STOP:
7406 
        break
7407 
      if fid == 1:
7408 
        if ftype == TType.I64:
7409 
          self.transactionId = iprot.readI64();
7410 
        else:
7411 
          iprot.skip(ftype)
7412 
      else:
7413 
        iprot.skip(ftype)
7414 
      iprot.readFieldEnd()
7415 
    iprot.readStructEnd()
7416 
 
7417 
  def write(self, oprot):
7418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7420 
      return
1398 varun.gupt 7421 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 7422 
    if self.transactionId is not None:
1382 varun.gupt 7423 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7424 
      oprot.writeI64(self.transactionId)
7425 
      oprot.writeFieldEnd()
7426 
    oprot.writeFieldStop()
7427 
    oprot.writeStructEnd()
7428 
 
3431 rajveer 7429 
  def validate(self):
7430 
    return
7431 
 
7432 
 
1382 varun.gupt 7433 
  def __repr__(self):
7434 
    L = ['%s=%r' % (key, value)
7435 
      for key, value in self.__dict__.iteritems()]
7436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7437 
 
7438 
  def __eq__(self, other):
7439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7440 
 
7441 
  def __ne__(self, other):
7442 
    return not (self == other)
7443 
 
1398 varun.gupt 7444 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 7445 
  """
7446 
  Attributes:
7447 
   - success
7448 
   - ex
7449 
  """
7450 
 
7451 
  thrift_spec = (
7452 
    (0, TType.BOOL, 'success', None, None, ), # 0
7453 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7454 
  )
7455 
 
7456 
  def __init__(self, success=None, ex=None,):
7457 
    self.success = success
7458 
    self.ex = ex
7459 
 
7460 
  def read(self, iprot):
7461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7463 
      return
7464 
    iprot.readStructBegin()
7465 
    while True:
7466 
      (fname, ftype, fid) = iprot.readFieldBegin()
7467 
      if ftype == TType.STOP:
7468 
        break
7469 
      if fid == 0:
7470 
        if ftype == TType.BOOL:
7471 
          self.success = iprot.readBool();
7472 
        else:
7473 
          iprot.skip(ftype)
7474 
      elif fid == 1:
7475 
        if ftype == TType.STRUCT:
7476 
          self.ex = TransactionServiceException()
7477 
          self.ex.read(iprot)
7478 
        else:
7479 
          iprot.skip(ftype)
7480 
      else:
7481 
        iprot.skip(ftype)
7482 
      iprot.readFieldEnd()
7483 
    iprot.readStructEnd()
7484 
 
7485 
  def write(self, oprot):
7486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7488 
      return
1398 varun.gupt 7489 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 7490 
    if self.success is not None:
1382 varun.gupt 7491 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7492 
      oprot.writeBool(self.success)
7493 
      oprot.writeFieldEnd()
3431 rajveer 7494 
    if self.ex is not None:
1382 varun.gupt 7495 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7496 
      self.ex.write(oprot)
7497 
      oprot.writeFieldEnd()
7498 
    oprot.writeFieldStop()
7499 
    oprot.writeStructEnd()
7500 
 
3431 rajveer 7501 
  def validate(self):
7502 
    return
7503 
 
7504 
 
1382 varun.gupt 7505 
  def __repr__(self):
7506 
    L = ['%s=%r' % (key, value)
7507 
      for key, value in self.__dict__.iteritems()]
7508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7509 
 
7510 
  def __eq__(self, other):
7511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7512 
 
7513 
  def __ne__(self, other):
7514 
    return not (self == other)
7515 
 
483 rajveer 7516 
class getAllOrders_args:
94 ashish 7517 
  """
7518 
  Attributes:
4801 anupam.sin 7519 
   - statuses
483 rajveer 7520 
   - from_date
7521 
   - to_date
7522 
   - warehouse_id
94 ashish 7523 
  """
7524 
 
7525 
  thrift_spec = (
7526 
    None, # 0
4801 anupam.sin 7527 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 7528 
    (2, TType.I64, 'from_date', None, None, ), # 2
7529 
    (3, TType.I64, 'to_date', None, None, ), # 3
7530 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 7531 
  )
7532 
 
4801 anupam.sin 7533 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
7534 
    self.statuses = statuses
483 rajveer 7535 
    self.from_date = from_date
7536 
    self.to_date = to_date
7537 
    self.warehouse_id = warehouse_id
94 ashish 7538 
 
7539 
  def read(self, iprot):
7540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7542 
      return
7543 
    iprot.readStructBegin()
7544 
    while True:
7545 
      (fname, ftype, fid) = iprot.readFieldBegin()
7546 
      if ftype == TType.STOP:
7547 
        break
7548 
      if fid == 1:
4801 anupam.sin 7549 
        if ftype == TType.LIST:
7550 
          self.statuses = []
5031 varun.gupt 7551 
          (_etype80, _size77) = iprot.readListBegin()
7552 
          for _i81 in xrange(_size77):
7553 
            _elem82 = iprot.readI32();
7554 
            self.statuses.append(_elem82)
4801 anupam.sin 7555 
          iprot.readListEnd()
94 ashish 7556 
        else:
7557 
          iprot.skip(ftype)
483 rajveer 7558 
      elif fid == 2:
7559 
        if ftype == TType.I64:
7560 
          self.from_date = iprot.readI64();
94 ashish 7561 
        else:
7562 
          iprot.skip(ftype)
483 rajveer 7563 
      elif fid == 3:
7564 
        if ftype == TType.I64:
7565 
          self.to_date = iprot.readI64();
94 ashish 7566 
        else:
7567 
          iprot.skip(ftype)
483 rajveer 7568 
      elif fid == 4:
94 ashish 7569 
        if ftype == TType.I64:
483 rajveer 7570 
          self.warehouse_id = iprot.readI64();
94 ashish 7571 
        else:
7572 
          iprot.skip(ftype)
7573 
      else:
7574 
        iprot.skip(ftype)
7575 
      iprot.readFieldEnd()
7576 
    iprot.readStructEnd()
7577 
 
7578 
  def write(self, oprot):
7579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7581 
      return
483 rajveer 7582 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 7583 
    if self.statuses is not None:
7584 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7585 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7586 
      for iter83 in self.statuses:
7587 
        oprot.writeI32(iter83)
4801 anupam.sin 7588 
      oprot.writeListEnd()
94 ashish 7589 
      oprot.writeFieldEnd()
3431 rajveer 7590 
    if self.from_date is not None:
483 rajveer 7591 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7592 
      oprot.writeI64(self.from_date)
94 ashish 7593 
      oprot.writeFieldEnd()
3431 rajveer 7594 
    if self.to_date is not None:
483 rajveer 7595 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7596 
      oprot.writeI64(self.to_date)
94 ashish 7597 
      oprot.writeFieldEnd()
3431 rajveer 7598 
    if self.warehouse_id is not None:
483 rajveer 7599 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7600 
      oprot.writeI64(self.warehouse_id)
94 ashish 7601 
      oprot.writeFieldEnd()
7602 
    oprot.writeFieldStop()
7603 
    oprot.writeStructEnd()
7604 
 
3431 rajveer 7605 
  def validate(self):
7606 
    return
7607 
 
7608 
 
94 ashish 7609 
  def __repr__(self):
7610 
    L = ['%s=%r' % (key, value)
7611 
      for key, value in self.__dict__.iteritems()]
7612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7613 
 
7614 
  def __eq__(self, other):
7615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7616 
 
7617 
  def __ne__(self, other):
7618 
    return not (self == other)
7619 
 
483 rajveer 7620 
class getAllOrders_result:
94 ashish 7621 
  """
7622 
  Attributes:
7623 
   - success
7624 
   - ex
7625 
  """
7626 
 
7627 
  thrift_spec = (
483 rajveer 7628 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 7629 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7630 
  )
7631 
 
7632 
  def __init__(self, success=None, ex=None,):
7633 
    self.success = success
7634 
    self.ex = ex
7635 
 
7636 
  def read(self, iprot):
7637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7639 
      return
7640 
    iprot.readStructBegin()
7641 
    while True:
7642 
      (fname, ftype, fid) = iprot.readFieldBegin()
7643 
      if ftype == TType.STOP:
7644 
        break
7645 
      if fid == 0:
483 rajveer 7646 
        if ftype == TType.LIST:
7647 
          self.success = []
5031 varun.gupt 7648 
          (_etype87, _size84) = iprot.readListBegin()
7649 
          for _i88 in xrange(_size84):
7650 
            _elem89 = Order()
7651 
            _elem89.read(iprot)
7652 
            self.success.append(_elem89)
483 rajveer 7653 
          iprot.readListEnd()
94 ashish 7654 
        else:
7655 
          iprot.skip(ftype)
7656 
      elif fid == 1:
7657 
        if ftype == TType.STRUCT:
7658 
          self.ex = TransactionServiceException()
7659 
          self.ex.read(iprot)
7660 
        else:
7661 
          iprot.skip(ftype)
7662 
      else:
7663 
        iprot.skip(ftype)
7664 
      iprot.readFieldEnd()
7665 
    iprot.readStructEnd()
7666 
 
7667 
  def write(self, oprot):
7668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7670 
      return
483 rajveer 7671 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 7672 
    if self.success is not None:
483 rajveer 7673 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7674 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7675 
      for iter90 in self.success:
7676 
        iter90.write(oprot)
483 rajveer 7677 
      oprot.writeListEnd()
94 ashish 7678 
      oprot.writeFieldEnd()
3431 rajveer 7679 
    if self.ex is not None:
94 ashish 7680 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7681 
      self.ex.write(oprot)
7682 
      oprot.writeFieldEnd()
7683 
    oprot.writeFieldStop()
7684 
    oprot.writeStructEnd()
7685 
 
3431 rajveer 7686 
  def validate(self):
7687 
    return
7688 
 
7689 
 
94 ashish 7690 
  def __repr__(self):
7691 
    L = ['%s=%r' % (key, value)
7692 
      for key, value in self.__dict__.iteritems()]
7693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7694 
 
7695 
  def __eq__(self, other):
7696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7697 
 
7698 
  def __ne__(self, other):
7699 
    return not (self == other)
7700 
 
4133 chandransh 7701 
class getOrdersInBatch_args:
7702 
  """
7703 
  Attributes:
7704 
   - statuses
7705 
   - offset
7706 
   - limit
7707 
   - warehouse_id
7708 
  """
7709 
 
7710 
  thrift_spec = (
7711 
    None, # 0
7712 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7713 
    (2, TType.I64, 'offset', None, None, ), # 2
7714 
    (3, TType.I64, 'limit', None, None, ), # 3
7715 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7716 
  )
7717 
 
7718 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
7719 
    self.statuses = statuses
7720 
    self.offset = offset
7721 
    self.limit = limit
7722 
    self.warehouse_id = warehouse_id
7723 
 
7724 
  def read(self, iprot):
7725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7727 
      return
7728 
    iprot.readStructBegin()
7729 
    while True:
7730 
      (fname, ftype, fid) = iprot.readFieldBegin()
7731 
      if ftype == TType.STOP:
7732 
        break
7733 
      if fid == 1:
7734 
        if ftype == TType.LIST:
7735 
          self.statuses = []
5031 varun.gupt 7736 
          (_etype94, _size91) = iprot.readListBegin()
7737 
          for _i95 in xrange(_size91):
7738 
            _elem96 = iprot.readI32();
7739 
            self.statuses.append(_elem96)
4133 chandransh 7740 
          iprot.readListEnd()
7741 
        else:
7742 
          iprot.skip(ftype)
7743 
      elif fid == 2:
7744 
        if ftype == TType.I64:
7745 
          self.offset = iprot.readI64();
7746 
        else:
7747 
          iprot.skip(ftype)
7748 
      elif fid == 3:
7749 
        if ftype == TType.I64:
7750 
          self.limit = iprot.readI64();
7751 
        else:
7752 
          iprot.skip(ftype)
7753 
      elif fid == 4:
7754 
        if ftype == TType.I64:
7755 
          self.warehouse_id = iprot.readI64();
7756 
        else:
7757 
          iprot.skip(ftype)
7758 
      else:
7759 
        iprot.skip(ftype)
7760 
      iprot.readFieldEnd()
7761 
    iprot.readStructEnd()
7762 
 
7763 
  def write(self, oprot):
7764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7766 
      return
7767 
    oprot.writeStructBegin('getOrdersInBatch_args')
7768 
    if self.statuses is not None:
7769 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7770 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7771 
      for iter97 in self.statuses:
7772 
        oprot.writeI32(iter97)
4133 chandransh 7773 
      oprot.writeListEnd()
7774 
      oprot.writeFieldEnd()
7775 
    if self.offset is not None:
7776 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7777 
      oprot.writeI64(self.offset)
7778 
      oprot.writeFieldEnd()
7779 
    if self.limit is not None:
7780 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7781 
      oprot.writeI64(self.limit)
7782 
      oprot.writeFieldEnd()
7783 
    if self.warehouse_id is not None:
7784 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7785 
      oprot.writeI64(self.warehouse_id)
7786 
      oprot.writeFieldEnd()
7787 
    oprot.writeFieldStop()
7788 
    oprot.writeStructEnd()
7789 
 
7790 
  def validate(self):
7791 
    return
7792 
 
7793 
 
7794 
  def __repr__(self):
7795 
    L = ['%s=%r' % (key, value)
7796 
      for key, value in self.__dict__.iteritems()]
7797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7798 
 
7799 
  def __eq__(self, other):
7800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7801 
 
7802 
  def __ne__(self, other):
7803 
    return not (self == other)
7804 
 
7805 
class getOrdersInBatch_result:
7806 
  """
7807 
  Attributes:
7808 
   - success
7809 
   - ex
7810 
  """
7811 
 
7812 
  thrift_spec = (
7813 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7814 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7815 
  )
7816 
 
7817 
  def __init__(self, success=None, ex=None,):
7818 
    self.success = success
7819 
    self.ex = ex
7820 
 
7821 
  def read(self, iprot):
7822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7824 
      return
7825 
    iprot.readStructBegin()
7826 
    while True:
7827 
      (fname, ftype, fid) = iprot.readFieldBegin()
7828 
      if ftype == TType.STOP:
7829 
        break
7830 
      if fid == 0:
7831 
        if ftype == TType.LIST:
7832 
          self.success = []
5031 varun.gupt 7833 
          (_etype101, _size98) = iprot.readListBegin()
7834 
          for _i102 in xrange(_size98):
7835 
            _elem103 = Order()
7836 
            _elem103.read(iprot)
7837 
            self.success.append(_elem103)
4133 chandransh 7838 
          iprot.readListEnd()
7839 
        else:
7840 
          iprot.skip(ftype)
7841 
      elif fid == 1:
7842 
        if ftype == TType.STRUCT:
7843 
          self.ex = TransactionServiceException()
7844 
          self.ex.read(iprot)
7845 
        else:
7846 
          iprot.skip(ftype)
7847 
      else:
7848 
        iprot.skip(ftype)
7849 
      iprot.readFieldEnd()
7850 
    iprot.readStructEnd()
7851 
 
7852 
  def write(self, oprot):
7853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7855 
      return
7856 
    oprot.writeStructBegin('getOrdersInBatch_result')
7857 
    if self.success is not None:
7858 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7859 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7860 
      for iter104 in self.success:
7861 
        iter104.write(oprot)
4133 chandransh 7862 
      oprot.writeListEnd()
7863 
      oprot.writeFieldEnd()
7864 
    if self.ex is not None:
7865 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7866 
      self.ex.write(oprot)
7867 
      oprot.writeFieldEnd()
7868 
    oprot.writeFieldStop()
7869 
    oprot.writeStructEnd()
7870 
 
7871 
  def validate(self):
7872 
    return
7873 
 
7874 
 
7875 
  def __repr__(self):
7876 
    L = ['%s=%r' % (key, value)
7877 
      for key, value in self.__dict__.iteritems()]
7878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7879 
 
7880 
  def __eq__(self, other):
7881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7882 
 
7883 
  def __ne__(self, other):
7884 
    return not (self == other)
7885 
 
7886 
class getOrderCount_args:
7887 
  """
7888 
  Attributes:
7889 
   - statuses
7890 
   - warehouseId
7891 
  """
7892 
 
7893 
  thrift_spec = (
7894 
    None, # 0
7895 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7896 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7897 
  )
7898 
 
7899 
  def __init__(self, statuses=None, warehouseId=None,):
7900 
    self.statuses = statuses
7901 
    self.warehouseId = warehouseId
7902 
 
7903 
  def read(self, iprot):
7904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7906 
      return
7907 
    iprot.readStructBegin()
7908 
    while True:
7909 
      (fname, ftype, fid) = iprot.readFieldBegin()
7910 
      if ftype == TType.STOP:
7911 
        break
7912 
      if fid == 1:
7913 
        if ftype == TType.LIST:
7914 
          self.statuses = []
5031 varun.gupt 7915 
          (_etype108, _size105) = iprot.readListBegin()
7916 
          for _i109 in xrange(_size105):
7917 
            _elem110 = iprot.readI32();
7918 
            self.statuses.append(_elem110)
4133 chandransh 7919 
          iprot.readListEnd()
7920 
        else:
7921 
          iprot.skip(ftype)
7922 
      elif fid == 2:
7923 
        if ftype == TType.I64:
7924 
          self.warehouseId = iprot.readI64();
7925 
        else:
7926 
          iprot.skip(ftype)
7927 
      else:
7928 
        iprot.skip(ftype)
7929 
      iprot.readFieldEnd()
7930 
    iprot.readStructEnd()
7931 
 
7932 
  def write(self, oprot):
7933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7935 
      return
7936 
    oprot.writeStructBegin('getOrderCount_args')
7937 
    if self.statuses is not None:
7938 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7939 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7940 
      for iter111 in self.statuses:
7941 
        oprot.writeI32(iter111)
4133 chandransh 7942 
      oprot.writeListEnd()
7943 
      oprot.writeFieldEnd()
7944 
    if self.warehouseId is not None:
7945 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7946 
      oprot.writeI64(self.warehouseId)
7947 
      oprot.writeFieldEnd()
7948 
    oprot.writeFieldStop()
7949 
    oprot.writeStructEnd()
7950 
 
7951 
  def validate(self):
7952 
    return
7953 
 
7954 
 
7955 
  def __repr__(self):
7956 
    L = ['%s=%r' % (key, value)
7957 
      for key, value in self.__dict__.iteritems()]
7958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7959 
 
7960 
  def __eq__(self, other):
7961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7962 
 
7963 
  def __ne__(self, other):
7964 
    return not (self == other)
7965 
 
7966 
class getOrderCount_result:
7967 
  """
7968 
  Attributes:
7969 
   - success
7970 
   - ex
7971 
  """
7972 
 
7973 
  thrift_spec = (
7974 
    (0, TType.I32, 'success', None, None, ), # 0
7975 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7976 
  )
7977 
 
7978 
  def __init__(self, success=None, ex=None,):
7979 
    self.success = success
7980 
    self.ex = ex
7981 
 
7982 
  def read(self, iprot):
7983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7985 
      return
7986 
    iprot.readStructBegin()
7987 
    while True:
7988 
      (fname, ftype, fid) = iprot.readFieldBegin()
7989 
      if ftype == TType.STOP:
7990 
        break
7991 
      if fid == 0:
7992 
        if ftype == TType.I32:
7993 
          self.success = iprot.readI32();
7994 
        else:
7995 
          iprot.skip(ftype)
7996 
      elif fid == 1:
7997 
        if ftype == TType.STRUCT:
7998 
          self.ex = TransactionServiceException()
7999 
          self.ex.read(iprot)
8000 
        else:
8001 
          iprot.skip(ftype)
8002 
      else:
8003 
        iprot.skip(ftype)
8004 
      iprot.readFieldEnd()
8005 
    iprot.readStructEnd()
8006 
 
8007 
  def write(self, oprot):
8008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8010 
      return
8011 
    oprot.writeStructBegin('getOrderCount_result')
8012 
    if self.success is not None:
8013 
      oprot.writeFieldBegin('success', TType.I32, 0)
8014 
      oprot.writeI32(self.success)
8015 
      oprot.writeFieldEnd()
8016 
    if self.ex is not None:
8017 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8018 
      self.ex.write(oprot)
8019 
      oprot.writeFieldEnd()
8020 
    oprot.writeFieldStop()
8021 
    oprot.writeStructEnd()
8022 
 
8023 
  def validate(self):
8024 
    return
8025 
 
8026 
 
8027 
  def __repr__(self):
8028 
    L = ['%s=%r' % (key, value)
8029 
      for key, value in self.__dict__.iteritems()]
8030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8031 
 
8032 
  def __eq__(self, other):
8033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8034 
 
8035 
  def __ne__(self, other):
8036 
    return not (self == other)
8037 
 
999 varun.gupt 8038 
class getOrdersByBillingDate_args:
8039 
  """
8040 
  Attributes:
8041 
   - status
8042 
   - start_billing_date
8043 
   - end_billing_date
8044 
   - warehouse_id
8045 
  """
8046 
 
8047 
  thrift_spec = (
8048 
    None, # 0
8049 
    (1, TType.I32, 'status', None, None, ), # 1
8050 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
8051 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
8052 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8053 
  )
8054 
 
8055 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
8056 
    self.status = status
8057 
    self.start_billing_date = start_billing_date
8058 
    self.end_billing_date = end_billing_date
8059 
    self.warehouse_id = warehouse_id
8060 
 
8061 
  def read(self, iprot):
8062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8064 
      return
8065 
    iprot.readStructBegin()
8066 
    while True:
8067 
      (fname, ftype, fid) = iprot.readFieldBegin()
8068 
      if ftype == TType.STOP:
8069 
        break
8070 
      if fid == 1:
8071 
        if ftype == TType.I32:
8072 
          self.status = iprot.readI32();
8073 
        else:
8074 
          iprot.skip(ftype)
8075 
      elif fid == 2:
8076 
        if ftype == TType.I64:
8077 
          self.start_billing_date = iprot.readI64();
8078 
        else:
8079 
          iprot.skip(ftype)
8080 
      elif fid == 3:
8081 
        if ftype == TType.I64:
8082 
          self.end_billing_date = iprot.readI64();
8083 
        else:
8084 
          iprot.skip(ftype)
8085 
      elif fid == 4:
8086 
        if ftype == TType.I64:
8087 
          self.warehouse_id = iprot.readI64();
8088 
        else:
8089 
          iprot.skip(ftype)
8090 
      else:
8091 
        iprot.skip(ftype)
8092 
      iprot.readFieldEnd()
8093 
    iprot.readStructEnd()
8094 
 
8095 
  def write(self, oprot):
8096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8098 
      return
8099 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 8100 
    if self.status is not None:
999 varun.gupt 8101 
      oprot.writeFieldBegin('status', TType.I32, 1)
8102 
      oprot.writeI32(self.status)
8103 
      oprot.writeFieldEnd()
3431 rajveer 8104 
    if self.start_billing_date is not None:
999 varun.gupt 8105 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
8106 
      oprot.writeI64(self.start_billing_date)
8107 
      oprot.writeFieldEnd()
3431 rajveer 8108 
    if self.end_billing_date is not None:
999 varun.gupt 8109 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
8110 
      oprot.writeI64(self.end_billing_date)
8111 
      oprot.writeFieldEnd()
3431 rajveer 8112 
    if self.warehouse_id is not None:
999 varun.gupt 8113 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8114 
      oprot.writeI64(self.warehouse_id)
8115 
      oprot.writeFieldEnd()
8116 
    oprot.writeFieldStop()
8117 
    oprot.writeStructEnd()
8118 
 
3431 rajveer 8119 
  def validate(self):
8120 
    return
8121 
 
8122 
 
999 varun.gupt 8123 
  def __repr__(self):
8124 
    L = ['%s=%r' % (key, value)
8125 
      for key, value in self.__dict__.iteritems()]
8126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8127 
 
8128 
  def __eq__(self, other):
8129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8130 
 
8131 
  def __ne__(self, other):
8132 
    return not (self == other)
8133 
 
8134 
class getOrdersByBillingDate_result:
8135 
  """
8136 
  Attributes:
8137 
   - success
8138 
   - ex
8139 
  """
8140 
 
8141 
  thrift_spec = (
8142 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8143 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8144 
  )
8145 
 
8146 
  def __init__(self, success=None, ex=None,):
8147 
    self.success = success
8148 
    self.ex = ex
8149 
 
8150 
  def read(self, iprot):
8151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8153 
      return
8154 
    iprot.readStructBegin()
8155 
    while True:
8156 
      (fname, ftype, fid) = iprot.readFieldBegin()
8157 
      if ftype == TType.STOP:
8158 
        break
8159 
      if fid == 0:
8160 
        if ftype == TType.LIST:
8161 
          self.success = []
5031 varun.gupt 8162 
          (_etype115, _size112) = iprot.readListBegin()
8163 
          for _i116 in xrange(_size112):
8164 
            _elem117 = Order()
8165 
            _elem117.read(iprot)
8166 
            self.success.append(_elem117)
999 varun.gupt 8167 
          iprot.readListEnd()
8168 
        else:
8169 
          iprot.skip(ftype)
8170 
      elif fid == 1:
8171 
        if ftype == TType.STRUCT:
8172 
          self.ex = TransactionServiceException()
8173 
          self.ex.read(iprot)
8174 
        else:
8175 
          iprot.skip(ftype)
8176 
      else:
8177 
        iprot.skip(ftype)
8178 
      iprot.readFieldEnd()
8179 
    iprot.readStructEnd()
8180 
 
8181 
  def write(self, oprot):
8182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8184 
      return
8185 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 8186 
    if self.success is not None:
999 varun.gupt 8187 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8188 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8189 
      for iter118 in self.success:
8190 
        iter118.write(oprot)
999 varun.gupt 8191 
      oprot.writeListEnd()
8192 
      oprot.writeFieldEnd()
3431 rajveer 8193 
    if self.ex is not None:
999 varun.gupt 8194 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8195 
      self.ex.write(oprot)
8196 
      oprot.writeFieldEnd()
8197 
    oprot.writeFieldStop()
8198 
    oprot.writeStructEnd()
8199 
 
3431 rajveer 8200 
  def validate(self):
8201 
    return
8202 
 
8203 
 
999 varun.gupt 8204 
  def __repr__(self):
8205 
    L = ['%s=%r' % (key, value)
8206 
      for key, value in self.__dict__.iteritems()]
8207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8208 
 
8209 
  def __eq__(self, other):
8210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8211 
 
8212 
  def __ne__(self, other):
8213 
    return not (self == other)
8214 
 
3427 chandransh 8215 
class getOrdersByShippingDate_args:
8216 
  """
8217 
  Attributes:
8218 
   - fromShippingDate
8219 
   - toShippingDate
8220 
   - providerId
8221 
   - warehouseId
3451 chandransh 8222 
   - cod
3427 chandransh 8223 
  """
8224 
 
8225 
  thrift_spec = (
8226 
    None, # 0
8227 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
8228 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
8229 
    (3, TType.I64, 'providerId', None, None, ), # 3
8230 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 8231 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 8232 
  )
8233 
 
3451 chandransh 8234 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 8235 
    self.fromShippingDate = fromShippingDate
8236 
    self.toShippingDate = toShippingDate
8237 
    self.providerId = providerId
8238 
    self.warehouseId = warehouseId
3451 chandransh 8239 
    self.cod = cod
3427 chandransh 8240 
 
8241 
  def read(self, iprot):
8242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8244 
      return
8245 
    iprot.readStructBegin()
8246 
    while True:
8247 
      (fname, ftype, fid) = iprot.readFieldBegin()
8248 
      if ftype == TType.STOP:
8249 
        break
8250 
      if fid == 1:
8251 
        if ftype == TType.I64:
8252 
          self.fromShippingDate = iprot.readI64();
8253 
        else:
8254 
          iprot.skip(ftype)
8255 
      elif fid == 2:
8256 
        if ftype == TType.I64:
8257 
          self.toShippingDate = iprot.readI64();
8258 
        else:
8259 
          iprot.skip(ftype)
8260 
      elif fid == 3:
8261 
        if ftype == TType.I64:
8262 
          self.providerId = iprot.readI64();
8263 
        else:
8264 
          iprot.skip(ftype)
8265 
      elif fid == 4:
8266 
        if ftype == TType.I64:
8267 
          self.warehouseId = iprot.readI64();
8268 
        else:
8269 
          iprot.skip(ftype)
3451 chandransh 8270 
      elif fid == 5:
8271 
        if ftype == TType.BOOL:
8272 
          self.cod = iprot.readBool();
8273 
        else:
8274 
          iprot.skip(ftype)
3427 chandransh 8275 
      else:
8276 
        iprot.skip(ftype)
8277 
      iprot.readFieldEnd()
8278 
    iprot.readStructEnd()
8279 
 
8280 
  def write(self, oprot):
8281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8283 
      return
8284 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 8285 
    if self.fromShippingDate is not None:
3427 chandransh 8286 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
8287 
      oprot.writeI64(self.fromShippingDate)
8288 
      oprot.writeFieldEnd()
3431 rajveer 8289 
    if self.toShippingDate is not None:
3427 chandransh 8290 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
8291 
      oprot.writeI64(self.toShippingDate)
8292 
      oprot.writeFieldEnd()
3431 rajveer 8293 
    if self.providerId is not None:
3427 chandransh 8294 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
8295 
      oprot.writeI64(self.providerId)
8296 
      oprot.writeFieldEnd()
3431 rajveer 8297 
    if self.warehouseId is not None:
3427 chandransh 8298 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
8299 
      oprot.writeI64(self.warehouseId)
8300 
      oprot.writeFieldEnd()
3451 chandransh 8301 
    if self.cod is not None:
8302 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
8303 
      oprot.writeBool(self.cod)
8304 
      oprot.writeFieldEnd()
3427 chandransh 8305 
    oprot.writeFieldStop()
8306 
    oprot.writeStructEnd()
8307 
 
3431 rajveer 8308 
  def validate(self):
8309 
    return
8310 
 
8311 
 
3427 chandransh 8312 
  def __repr__(self):
8313 
    L = ['%s=%r' % (key, value)
8314 
      for key, value in self.__dict__.iteritems()]
8315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8316 
 
8317 
  def __eq__(self, other):
8318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8319 
 
8320 
  def __ne__(self, other):
8321 
    return not (self == other)
8322 
 
8323 
class getOrdersByShippingDate_result:
8324 
  """
8325 
  Attributes:
8326 
   - success
8327 
   - ex
8328 
  """
8329 
 
8330 
  thrift_spec = (
8331 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8332 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8333 
  )
8334 
 
8335 
  def __init__(self, success=None, ex=None,):
8336 
    self.success = success
8337 
    self.ex = ex
8338 
 
8339 
  def read(self, iprot):
8340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8342 
      return
8343 
    iprot.readStructBegin()
8344 
    while True:
8345 
      (fname, ftype, fid) = iprot.readFieldBegin()
8346 
      if ftype == TType.STOP:
8347 
        break
8348 
      if fid == 0:
8349 
        if ftype == TType.LIST:
8350 
          self.success = []
5031 varun.gupt 8351 
          (_etype122, _size119) = iprot.readListBegin()
8352 
          for _i123 in xrange(_size119):
8353 
            _elem124 = Order()
8354 
            _elem124.read(iprot)
8355 
            self.success.append(_elem124)
3427 chandransh 8356 
          iprot.readListEnd()
8357 
        else:
8358 
          iprot.skip(ftype)
8359 
      elif fid == 1:
8360 
        if ftype == TType.STRUCT:
8361 
          self.ex = TransactionServiceException()
8362 
          self.ex.read(iprot)
8363 
        else:
8364 
          iprot.skip(ftype)
8365 
      else:
8366 
        iprot.skip(ftype)
8367 
      iprot.readFieldEnd()
8368 
    iprot.readStructEnd()
8369 
 
8370 
  def write(self, oprot):
8371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8373 
      return
8374 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 8375 
    if self.success is not None:
3427 chandransh 8376 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8377 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8378 
      for iter125 in self.success:
8379 
        iter125.write(oprot)
3427 chandransh 8380 
      oprot.writeListEnd()
8381 
      oprot.writeFieldEnd()
3431 rajveer 8382 
    if self.ex is not None:
3427 chandransh 8383 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8384 
      self.ex.write(oprot)
8385 
      oprot.writeFieldEnd()
8386 
    oprot.writeFieldStop()
8387 
    oprot.writeStructEnd()
8388 
 
3431 rajveer 8389 
  def validate(self):
8390 
    return
8391 
 
8392 
 
3427 chandransh 8393 
  def __repr__(self):
8394 
    L = ['%s=%r' % (key, value)
8395 
      for key, value in self.__dict__.iteritems()]
8396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8397 
 
8398 
  def __eq__(self, other):
8399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8400 
 
8401 
  def __ne__(self, other):
8402 
    return not (self == other)
8403 
 
1382 varun.gupt 8404 
class getReturnableOrdersForCustomer_args:
8405 
  """
8406 
  Attributes:
8407 
   - customer_id
8408 
   - limit
8409 
  """
8410 
 
8411 
  thrift_spec = (
8412 
    None, # 0
8413 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8414 
    (2, TType.I64, 'limit', None, None, ), # 2
8415 
  )
8416 
 
8417 
  def __init__(self, customer_id=None, limit=None,):
8418 
    self.customer_id = customer_id
8419 
    self.limit = limit
8420 
 
8421 
  def read(self, iprot):
8422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8424 
      return
8425 
    iprot.readStructBegin()
8426 
    while True:
8427 
      (fname, ftype, fid) = iprot.readFieldBegin()
8428 
      if ftype == TType.STOP:
8429 
        break
8430 
      if fid == 1:
8431 
        if ftype == TType.I64:
8432 
          self.customer_id = iprot.readI64();
8433 
        else:
8434 
          iprot.skip(ftype)
8435 
      elif fid == 2:
8436 
        if ftype == TType.I64:
8437 
          self.limit = iprot.readI64();
8438 
        else:
8439 
          iprot.skip(ftype)
8440 
      else:
8441 
        iprot.skip(ftype)
8442 
      iprot.readFieldEnd()
8443 
    iprot.readStructEnd()
8444 
 
8445 
  def write(self, oprot):
8446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8448 
      return
8449 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 8450 
    if self.customer_id is not None:
1382 varun.gupt 8451 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8452 
      oprot.writeI64(self.customer_id)
8453 
      oprot.writeFieldEnd()
3431 rajveer 8454 
    if self.limit is not None:
1382 varun.gupt 8455 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8456 
      oprot.writeI64(self.limit)
8457 
      oprot.writeFieldEnd()
8458 
    oprot.writeFieldStop()
8459 
    oprot.writeStructEnd()
8460 
 
3431 rajveer 8461 
  def validate(self):
8462 
    return
8463 
 
8464 
 
1382 varun.gupt 8465 
  def __repr__(self):
8466 
    L = ['%s=%r' % (key, value)
8467 
      for key, value in self.__dict__.iteritems()]
8468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8469 
 
8470 
  def __eq__(self, other):
8471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8472 
 
8473 
  def __ne__(self, other):
8474 
    return not (self == other)
8475 
 
8476 
class getReturnableOrdersForCustomer_result:
8477 
  """
8478 
  Attributes:
8479 
   - success
8480 
   - ex
8481 
  """
8482 
 
8483 
  thrift_spec = (
8484 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8485 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8486 
  )
8487 
 
8488 
  def __init__(self, success=None, ex=None,):
8489 
    self.success = success
8490 
    self.ex = ex
8491 
 
8492 
  def read(self, iprot):
8493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8495 
      return
8496 
    iprot.readStructBegin()
8497 
    while True:
8498 
      (fname, ftype, fid) = iprot.readFieldBegin()
8499 
      if ftype == TType.STOP:
8500 
        break
8501 
      if fid == 0:
8502 
        if ftype == TType.LIST:
8503 
          self.success = []
5031 varun.gupt 8504 
          (_etype129, _size126) = iprot.readListBegin()
8505 
          for _i130 in xrange(_size126):
8506 
            _elem131 = iprot.readI64();
8507 
            self.success.append(_elem131)
1382 varun.gupt 8508 
          iprot.readListEnd()
8509 
        else:
8510 
          iprot.skip(ftype)
8511 
      elif fid == 1:
8512 
        if ftype == TType.STRUCT:
8513 
          self.ex = TransactionServiceException()
8514 
          self.ex.read(iprot)
8515 
        else:
8516 
          iprot.skip(ftype)
8517 
      else:
8518 
        iprot.skip(ftype)
8519 
      iprot.readFieldEnd()
8520 
    iprot.readStructEnd()
8521 
 
8522 
  def write(self, oprot):
8523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8525 
      return
8526 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 8527 
    if self.success is not None:
1382 varun.gupt 8528 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8529 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8530 
      for iter132 in self.success:
8531 
        oprot.writeI64(iter132)
1382 varun.gupt 8532 
      oprot.writeListEnd()
8533 
      oprot.writeFieldEnd()
3431 rajveer 8534 
    if self.ex is not None:
1382 varun.gupt 8535 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8536 
      self.ex.write(oprot)
8537 
      oprot.writeFieldEnd()
8538 
    oprot.writeFieldStop()
8539 
    oprot.writeStructEnd()
8540 
 
3431 rajveer 8541 
  def validate(self):
8542 
    return
8543 
 
8544 
 
1382 varun.gupt 8545 
  def __repr__(self):
8546 
    L = ['%s=%r' % (key, value)
8547 
      for key, value in self.__dict__.iteritems()]
8548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8549 
 
8550 
  def __eq__(self, other):
8551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8552 
 
8553 
  def __ne__(self, other):
8554 
    return not (self == other)
8555 
 
8556 
class getCancellableOrdersForCustomer_args:
8557 
  """
8558 
  Attributes:
8559 
   - customer_id
8560 
   - limit
8561 
  """
8562 
 
8563 
  thrift_spec = (
8564 
    None, # 0
8565 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8566 
    (2, TType.I64, 'limit', None, None, ), # 2
8567 
  )
8568 
 
8569 
  def __init__(self, customer_id=None, limit=None,):
8570 
    self.customer_id = customer_id
8571 
    self.limit = limit
8572 
 
8573 
  def read(self, iprot):
8574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8576 
      return
8577 
    iprot.readStructBegin()
8578 
    while True:
8579 
      (fname, ftype, fid) = iprot.readFieldBegin()
8580 
      if ftype == TType.STOP:
8581 
        break
8582 
      if fid == 1:
8583 
        if ftype == TType.I64:
8584 
          self.customer_id = iprot.readI64();
8585 
        else:
8586 
          iprot.skip(ftype)
8587 
      elif fid == 2:
8588 
        if ftype == TType.I64:
8589 
          self.limit = iprot.readI64();
8590 
        else:
8591 
          iprot.skip(ftype)
8592 
      else:
8593 
        iprot.skip(ftype)
8594 
      iprot.readFieldEnd()
8595 
    iprot.readStructEnd()
8596 
 
8597 
  def write(self, oprot):
8598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8600 
      return
8601 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 8602 
    if self.customer_id is not None:
1382 varun.gupt 8603 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8604 
      oprot.writeI64(self.customer_id)
8605 
      oprot.writeFieldEnd()
3431 rajveer 8606 
    if self.limit is not None:
1382 varun.gupt 8607 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8608 
      oprot.writeI64(self.limit)
8609 
      oprot.writeFieldEnd()
8610 
    oprot.writeFieldStop()
8611 
    oprot.writeStructEnd()
8612 
 
3431 rajveer 8613 
  def validate(self):
8614 
    return
8615 
 
8616 
 
1382 varun.gupt 8617 
  def __repr__(self):
8618 
    L = ['%s=%r' % (key, value)
8619 
      for key, value in self.__dict__.iteritems()]
8620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8621 
 
8622 
  def __eq__(self, other):
8623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8624 
 
8625 
  def __ne__(self, other):
8626 
    return not (self == other)
8627 
 
8628 
class getCancellableOrdersForCustomer_result:
8629 
  """
8630 
  Attributes:
8631 
   - success
8632 
   - ex
8633 
  """
8634 
 
8635 
  thrift_spec = (
8636 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8637 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8638 
  )
8639 
 
8640 
  def __init__(self, success=None, ex=None,):
8641 
    self.success = success
8642 
    self.ex = ex
8643 
 
8644 
  def read(self, iprot):
8645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8647 
      return
8648 
    iprot.readStructBegin()
8649 
    while True:
8650 
      (fname, ftype, fid) = iprot.readFieldBegin()
8651 
      if ftype == TType.STOP:
8652 
        break
8653 
      if fid == 0:
8654 
        if ftype == TType.LIST:
8655 
          self.success = []
5031 varun.gupt 8656 
          (_etype136, _size133) = iprot.readListBegin()
8657 
          for _i137 in xrange(_size133):
8658 
            _elem138 = iprot.readI64();
8659 
            self.success.append(_elem138)
1382 varun.gupt 8660 
          iprot.readListEnd()
8661 
        else:
8662 
          iprot.skip(ftype)
8663 
      elif fid == 1:
8664 
        if ftype == TType.STRUCT:
8665 
          self.ex = TransactionServiceException()
8666 
          self.ex.read(iprot)
8667 
        else:
8668 
          iprot.skip(ftype)
8669 
      else:
8670 
        iprot.skip(ftype)
8671 
      iprot.readFieldEnd()
8672 
    iprot.readStructEnd()
8673 
 
8674 
  def write(self, oprot):
8675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8677 
      return
8678 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 8679 
    if self.success is not None:
1382 varun.gupt 8680 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8681 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8682 
      for iter139 in self.success:
8683 
        oprot.writeI64(iter139)
1382 varun.gupt 8684 
      oprot.writeListEnd()
8685 
      oprot.writeFieldEnd()
3431 rajveer 8686 
    if self.ex is not None:
1382 varun.gupt 8687 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8688 
      self.ex.write(oprot)
8689 
      oprot.writeFieldEnd()
8690 
    oprot.writeFieldStop()
8691 
    oprot.writeStructEnd()
8692 
 
3431 rajveer 8693 
  def validate(self):
8694 
    return
8695 
 
8696 
 
1382 varun.gupt 8697 
  def __repr__(self):
8698 
    L = ['%s=%r' % (key, value)
8699 
      for key, value in self.__dict__.iteritems()]
8700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8701 
 
8702 
  def __eq__(self, other):
8703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8704 
 
8705 
  def __ne__(self, other):
8706 
    return not (self == other)
8707 
 
483 rajveer 8708 
class changeOrderStatus_args:
94 ashish 8709 
  """
8710 
  Attributes:
483 rajveer 8711 
   - orderId
8712 
   - status
8713 
   - description
94 ashish 8714 
  """
8715 
 
8716 
  thrift_spec = (
8717 
    None, # 0
483 rajveer 8718 
    (1, TType.I64, 'orderId', None, None, ), # 1
8719 
    (2, TType.I32, 'status', None, None, ), # 2
8720 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8721 
  )
8722 
 
483 rajveer 8723 
  def __init__(self, orderId=None, status=None, description=None,):
8724 
    self.orderId = orderId
8725 
    self.status = status
8726 
    self.description = description
94 ashish 8727 
 
8728 
  def read(self, iprot):
8729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8731 
      return
8732 
    iprot.readStructBegin()
8733 
    while True:
8734 
      (fname, ftype, fid) = iprot.readFieldBegin()
8735 
      if ftype == TType.STOP:
8736 
        break
8737 
      if fid == 1:
8738 
        if ftype == TType.I64:
483 rajveer 8739 
          self.orderId = iprot.readI64();
94 ashish 8740 
        else:
8741 
          iprot.skip(ftype)
8742 
      elif fid == 2:
483 rajveer 8743 
        if ftype == TType.I32:
8744 
          self.status = iprot.readI32();
94 ashish 8745 
        else:
8746 
          iprot.skip(ftype)
483 rajveer 8747 
      elif fid == 3:
8748 
        if ftype == TType.STRING:
8749 
          self.description = iprot.readString();
8750 
        else:
8751 
          iprot.skip(ftype)
94 ashish 8752 
      else:
8753 
        iprot.skip(ftype)
8754 
      iprot.readFieldEnd()
8755 
    iprot.readStructEnd()
8756 
 
8757 
  def write(self, oprot):
8758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8760 
      return
483 rajveer 8761 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 8762 
    if self.orderId is not None:
483 rajveer 8763 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8764 
      oprot.writeI64(self.orderId)
94 ashish 8765 
      oprot.writeFieldEnd()
3431 rajveer 8766 
    if self.status is not None:
483 rajveer 8767 
      oprot.writeFieldBegin('status', TType.I32, 2)
8768 
      oprot.writeI32(self.status)
94 ashish 8769 
      oprot.writeFieldEnd()
3431 rajveer 8770 
    if self.description is not None:
483 rajveer 8771 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8772 
      oprot.writeString(self.description)
8773 
      oprot.writeFieldEnd()
94 ashish 8774 
    oprot.writeFieldStop()
8775 
    oprot.writeStructEnd()
8776 
 
3431 rajveer 8777 
  def validate(self):
8778 
    return
8779 
 
8780 
 
94 ashish 8781 
  def __repr__(self):
8782 
    L = ['%s=%r' % (key, value)
8783 
      for key, value in self.__dict__.iteritems()]
8784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8785 
 
8786 
  def __eq__(self, other):
8787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8788 
 
8789 
  def __ne__(self, other):
8790 
    return not (self == other)
8791 
 
483 rajveer 8792 
class changeOrderStatus_result:
94 ashish 8793 
  """
8794 
  Attributes:
8795 
   - success
8796 
   - ex
8797 
  """
8798 
 
8799 
  thrift_spec = (
8800 
    (0, TType.BOOL, 'success', None, None, ), # 0
8801 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8802 
  )
8803 
 
8804 
  def __init__(self, success=None, ex=None,):
8805 
    self.success = success
8806 
    self.ex = ex
8807 
 
8808 
  def read(self, iprot):
8809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8811 
      return
8812 
    iprot.readStructBegin()
8813 
    while True:
8814 
      (fname, ftype, fid) = iprot.readFieldBegin()
8815 
      if ftype == TType.STOP:
8816 
        break
8817 
      if fid == 0:
8818 
        if ftype == TType.BOOL:
8819 
          self.success = iprot.readBool();
8820 
        else:
8821 
          iprot.skip(ftype)
8822 
      elif fid == 1:
8823 
        if ftype == TType.STRUCT:
8824 
          self.ex = TransactionServiceException()
8825 
          self.ex.read(iprot)
8826 
        else:
8827 
          iprot.skip(ftype)
8828 
      else:
8829 
        iprot.skip(ftype)
8830 
      iprot.readFieldEnd()
8831 
    iprot.readStructEnd()
8832 
 
8833 
  def write(self, oprot):
8834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8836 
      return
483 rajveer 8837 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 8838 
    if self.success is not None:
94 ashish 8839 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8840 
      oprot.writeBool(self.success)
8841 
      oprot.writeFieldEnd()
3431 rajveer 8842 
    if self.ex is not None:
94 ashish 8843 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8844 
      self.ex.write(oprot)
8845 
      oprot.writeFieldEnd()
8846 
    oprot.writeFieldStop()
8847 
    oprot.writeStructEnd()
8848 
 
3431 rajveer 8849 
  def validate(self):
8850 
    return
8851 
 
8852 
 
94 ashish 8853 
  def __repr__(self):
8854 
    L = ['%s=%r' % (key, value)
8855 
      for key, value in self.__dict__.iteritems()]
8856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8857 
 
8858 
  def __eq__(self, other):
8859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8860 
 
8861 
  def __ne__(self, other):
8862 
    return not (self == other)
8863 
 
3064 chandransh 8864 
class getOrdersForTransaction_args:
494 rajveer 8865 
  """
8866 
  Attributes:
3064 chandransh 8867 
   - transactionId
8868 
   - customerId
494 rajveer 8869 
  """
8870 
 
8871 
  thrift_spec = (
8872 
    None, # 0
3064 chandransh 8873 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8874 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 8875 
  )
8876 
 
3064 chandransh 8877 
  def __init__(self, transactionId=None, customerId=None,):
8878 
    self.transactionId = transactionId
8879 
    self.customerId = customerId
494 rajveer 8880 
 
8881 
  def read(self, iprot):
8882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8884 
      return
8885 
    iprot.readStructBegin()
8886 
    while True:
8887 
      (fname, ftype, fid) = iprot.readFieldBegin()
8888 
      if ftype == TType.STOP:
8889 
        break
8890 
      if fid == 1:
8891 
        if ftype == TType.I64:
3064 chandransh 8892 
          self.transactionId = iprot.readI64();
494 rajveer 8893 
        else:
8894 
          iprot.skip(ftype)
8895 
      elif fid == 2:
3064 chandransh 8896 
        if ftype == TType.I64:
8897 
          self.customerId = iprot.readI64();
494 rajveer 8898 
        else:
8899 
          iprot.skip(ftype)
8900 
      else:
8901 
        iprot.skip(ftype)
8902 
      iprot.readFieldEnd()
8903 
    iprot.readStructEnd()
8904 
 
8905 
  def write(self, oprot):
8906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8908 
      return
3064 chandransh 8909 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 8910 
    if self.transactionId is not None:
3064 chandransh 8911 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8912 
      oprot.writeI64(self.transactionId)
494 rajveer 8913 
      oprot.writeFieldEnd()
3431 rajveer 8914 
    if self.customerId is not None:
3064 chandransh 8915 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
8916 
      oprot.writeI64(self.customerId)
494 rajveer 8917 
      oprot.writeFieldEnd()
8918 
    oprot.writeFieldStop()
8919 
    oprot.writeStructEnd()
8920 
 
3431 rajveer 8921 
  def validate(self):
8922 
    return
8923 
 
8924 
 
494 rajveer 8925 
  def __repr__(self):
8926 
    L = ['%s=%r' % (key, value)
8927 
      for key, value in self.__dict__.iteritems()]
8928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8929 
 
8930 
  def __eq__(self, other):
8931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8932 
 
8933 
  def __ne__(self, other):
8934 
    return not (self == other)
8935 
 
3064 chandransh 8936 
class getOrdersForTransaction_result:
494 rajveer 8937 
  """
8938 
  Attributes:
8939 
   - success
8940 
   - ex
8941 
  """
8942 
 
8943 
  thrift_spec = (
3064 chandransh 8944 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 8945 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8946 
  )
8947 
 
8948 
  def __init__(self, success=None, ex=None,):
8949 
    self.success = success
8950 
    self.ex = ex
8951 
 
8952 
  def read(self, iprot):
8953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8955 
      return
8956 
    iprot.readStructBegin()
8957 
    while True:
8958 
      (fname, ftype, fid) = iprot.readFieldBegin()
8959 
      if ftype == TType.STOP:
8960 
        break
8961 
      if fid == 0:
3064 chandransh 8962 
        if ftype == TType.LIST:
8963 
          self.success = []
5031 varun.gupt 8964 
          (_etype143, _size140) = iprot.readListBegin()
8965 
          for _i144 in xrange(_size140):
8966 
            _elem145 = Order()
8967 
            _elem145.read(iprot)
8968 
            self.success.append(_elem145)
3064 chandransh 8969 
          iprot.readListEnd()
494 rajveer 8970 
        else:
8971 
          iprot.skip(ftype)
8972 
      elif fid == 1:
8973 
        if ftype == TType.STRUCT:
8974 
          self.ex = TransactionServiceException()
8975 
          self.ex.read(iprot)
8976 
        else:
8977 
          iprot.skip(ftype)
8978 
      else:
8979 
        iprot.skip(ftype)
8980 
      iprot.readFieldEnd()
8981 
    iprot.readStructEnd()
8982 
 
8983 
  def write(self, oprot):
8984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8986 
      return
3064 chandransh 8987 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 8988 
    if self.success is not None:
3064 chandransh 8989 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8990 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8991 
      for iter146 in self.success:
8992 
        iter146.write(oprot)
3064 chandransh 8993 
      oprot.writeListEnd()
494 rajveer 8994 
      oprot.writeFieldEnd()
3431 rajveer 8995 
    if self.ex is not None:
494 rajveer 8996 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8997 
      self.ex.write(oprot)
8998 
      oprot.writeFieldEnd()
8999 
    oprot.writeFieldStop()
9000 
    oprot.writeStructEnd()
9001 
 
3431 rajveer 9002 
  def validate(self):
9003 
    return
9004 
 
9005 
 
494 rajveer 9006 
  def __repr__(self):
9007 
    L = ['%s=%r' % (key, value)
9008 
      for key, value in self.__dict__.iteritems()]
9009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9010 
 
9011 
  def __eq__(self, other):
9012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9013 
 
9014 
  def __ne__(self, other):
9015 
    return not (self == other)
9016 
 
3064 chandransh 9017 
class getOrdersForCustomer_args:
1149 chandransh 9018 
  """
9019 
  Attributes:
3064 chandransh 9020 
   - customerId
9021 
   - from_date
9022 
   - to_date
9023 
   - statuses
1149 chandransh 9024 
  """
9025 
 
9026 
  thrift_spec = (
9027 
    None, # 0
3064 chandransh 9028 
    (1, TType.I64, 'customerId', None, None, ), # 1
9029 
    (2, TType.I64, 'from_date', None, None, ), # 2
9030 
    (3, TType.I64, 'to_date', None, None, ), # 3
9031 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 9032 
  )
9033 
 
3064 chandransh 9034 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
9035 
    self.customerId = customerId
9036 
    self.from_date = from_date
9037 
    self.to_date = to_date
9038 
    self.statuses = statuses
1149 chandransh 9039 
 
9040 
  def read(self, iprot):
9041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9043 
      return
9044 
    iprot.readStructBegin()
9045 
    while True:
9046 
      (fname, ftype, fid) = iprot.readFieldBegin()
9047 
      if ftype == TType.STOP:
9048 
        break
9049 
      if fid == 1:
9050 
        if ftype == TType.I64:
3064 chandransh 9051 
          self.customerId = iprot.readI64();
1149 chandransh 9052 
        else:
9053 
          iprot.skip(ftype)
9054 
      elif fid == 2:
9055 
        if ftype == TType.I64:
3064 chandransh 9056 
          self.from_date = iprot.readI64();
1149 chandransh 9057 
        else:
9058 
          iprot.skip(ftype)
2783 chandransh 9059 
      elif fid == 3:
9060 
        if ftype == TType.I64:
3064 chandransh 9061 
          self.to_date = iprot.readI64();
2783 chandransh 9062 
        else:
9063 
          iprot.skip(ftype)
9064 
      elif fid == 4:
3064 chandransh 9065 
        if ftype == TType.LIST:
9066 
          self.statuses = []
5031 varun.gupt 9067 
          (_etype150, _size147) = iprot.readListBegin()
9068 
          for _i151 in xrange(_size147):
9069 
            _elem152 = iprot.readI32();
9070 
            self.statuses.append(_elem152)
3064 chandransh 9071 
          iprot.readListEnd()
2783 chandransh 9072 
        else:
9073 
          iprot.skip(ftype)
1149 chandransh 9074 
      else:
9075 
        iprot.skip(ftype)
9076 
      iprot.readFieldEnd()
9077 
    iprot.readStructEnd()
9078 
 
9079 
  def write(self, oprot):
9080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9082 
      return
3064 chandransh 9083 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 9084 
    if self.customerId is not None:
3064 chandransh 9085 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9086 
      oprot.writeI64(self.customerId)
1149 chandransh 9087 
      oprot.writeFieldEnd()
3431 rajveer 9088 
    if self.from_date is not None:
3064 chandransh 9089 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9090 
      oprot.writeI64(self.from_date)
1149 chandransh 9091 
      oprot.writeFieldEnd()
3431 rajveer 9092 
    if self.to_date is not None:
3064 chandransh 9093 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9094 
      oprot.writeI64(self.to_date)
2783 chandransh 9095 
      oprot.writeFieldEnd()
3431 rajveer 9096 
    if self.statuses is not None:
3064 chandransh 9097 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
9098 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 9099 
      for iter153 in self.statuses:
9100 
        oprot.writeI32(iter153)
3064 chandransh 9101 
      oprot.writeListEnd()
2783 chandransh 9102 
      oprot.writeFieldEnd()
1149 chandransh 9103 
    oprot.writeFieldStop()
9104 
    oprot.writeStructEnd()
9105 
 
3431 rajveer 9106 
  def validate(self):
9107 
    return
9108 
 
9109 
 
1149 chandransh 9110 
  def __repr__(self):
9111 
    L = ['%s=%r' % (key, value)
9112 
      for key, value in self.__dict__.iteritems()]
9113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9114 
 
9115 
  def __eq__(self, other):
9116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9117 
 
9118 
  def __ne__(self, other):
9119 
    return not (self == other)
9120 
 
3064 chandransh 9121 
class getOrdersForCustomer_result:
1149 chandransh 9122 
  """
9123 
  Attributes:
9124 
   - success
9125 
   - ex
9126 
  """
9127 
 
9128 
  thrift_spec = (
3064 chandransh 9129 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 9130 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9131 
  )
9132 
 
9133 
  def __init__(self, success=None, ex=None,):
9134 
    self.success = success
9135 
    self.ex = ex
9136 
 
9137 
  def read(self, iprot):
9138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9140 
      return
9141 
    iprot.readStructBegin()
9142 
    while True:
9143 
      (fname, ftype, fid) = iprot.readFieldBegin()
9144 
      if ftype == TType.STOP:
9145 
        break
9146 
      if fid == 0:
3064 chandransh 9147 
        if ftype == TType.LIST:
9148 
          self.success = []
5031 varun.gupt 9149 
          (_etype157, _size154) = iprot.readListBegin()
9150 
          for _i158 in xrange(_size154):
9151 
            _elem159 = Order()
9152 
            _elem159.read(iprot)
9153 
            self.success.append(_elem159)
3064 chandransh 9154 
          iprot.readListEnd()
1149 chandransh 9155 
        else:
9156 
          iprot.skip(ftype)
9157 
      elif fid == 1:
9158 
        if ftype == TType.STRUCT:
9159 
          self.ex = TransactionServiceException()
9160 
          self.ex.read(iprot)
9161 
        else:
9162 
          iprot.skip(ftype)
9163 
      else:
9164 
        iprot.skip(ftype)
9165 
      iprot.readFieldEnd()
9166 
    iprot.readStructEnd()
9167 
 
9168 
  def write(self, oprot):
9169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9171 
      return
3064 chandransh 9172 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 9173 
    if self.success is not None:
3064 chandransh 9174 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9175 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9176 
      for iter160 in self.success:
9177 
        iter160.write(oprot)
3064 chandransh 9178 
      oprot.writeListEnd()
1149 chandransh 9179 
      oprot.writeFieldEnd()
3431 rajveer 9180 
    if self.ex is not None:
1149 chandransh 9181 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9182 
      self.ex.write(oprot)
9183 
      oprot.writeFieldEnd()
9184 
    oprot.writeFieldStop()
9185 
    oprot.writeStructEnd()
9186 
 
3431 rajveer 9187 
  def validate(self):
9188 
    return
9189 
 
9190 
 
1149 chandransh 9191 
  def __repr__(self):
9192 
    L = ['%s=%r' % (key, value)
9193 
      for key, value in self.__dict__.iteritems()]
9194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9195 
 
9196 
  def __eq__(self, other):
9197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9198 
 
9199 
  def __ne__(self, other):
9200 
    return not (self == other)
9201 
 
3064 chandransh 9202 
class createOrder_args:
921 rajveer 9203 
  """
9204 
  Attributes:
3064 chandransh 9205 
   - order
921 rajveer 9206 
  """
9207 
 
9208 
  thrift_spec = (
9209 
    None, # 0
3064 chandransh 9210 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 9211 
  )
9212 
 
3064 chandransh 9213 
  def __init__(self, order=None,):
9214 
    self.order = order
921 rajveer 9215 
 
9216 
  def read(self, iprot):
9217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9219 
      return
9220 
    iprot.readStructBegin()
9221 
    while True:
9222 
      (fname, ftype, fid) = iprot.readFieldBegin()
9223 
      if ftype == TType.STOP:
9224 
        break
9225 
      if fid == 1:
3064 chandransh 9226 
        if ftype == TType.STRUCT:
9227 
          self.order = Order()
9228 
          self.order.read(iprot)
921 rajveer 9229 
        else:
9230 
          iprot.skip(ftype)
9231 
      else:
9232 
        iprot.skip(ftype)
9233 
      iprot.readFieldEnd()
9234 
    iprot.readStructEnd()
9235 
 
9236 
  def write(self, oprot):
9237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9239 
      return
3064 chandransh 9240 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 9241 
    if self.order is not None:
3064 chandransh 9242 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
9243 
      self.order.write(oprot)
921 rajveer 9244 
      oprot.writeFieldEnd()
9245 
    oprot.writeFieldStop()
9246 
    oprot.writeStructEnd()
9247 
 
3431 rajveer 9248 
  def validate(self):
9249 
    return
9250 
 
9251 
 
921 rajveer 9252 
  def __repr__(self):
9253 
    L = ['%s=%r' % (key, value)
9254 
      for key, value in self.__dict__.iteritems()]
9255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9256 
 
9257 
  def __eq__(self, other):
9258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9259 
 
9260 
  def __ne__(self, other):
9261 
    return not (self == other)
9262 
 
3064 chandransh 9263 
class createOrder_result:
921 rajveer 9264 
  """
9265 
  Attributes:
9266 
   - success
9267 
   - ex
9268 
  """
9269 
 
9270 
  thrift_spec = (
3064 chandransh 9271 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 9272 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9273 
  )
9274 
 
9275 
  def __init__(self, success=None, ex=None,):
9276 
    self.success = success
9277 
    self.ex = ex
9278 
 
9279 
  def read(self, iprot):
9280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9282 
      return
9283 
    iprot.readStructBegin()
9284 
    while True:
9285 
      (fname, ftype, fid) = iprot.readFieldBegin()
9286 
      if ftype == TType.STOP:
9287 
        break
9288 
      if fid == 0:
3064 chandransh 9289 
        if ftype == TType.I64:
9290 
          self.success = iprot.readI64();
921 rajveer 9291 
        else:
9292 
          iprot.skip(ftype)
9293 
      elif fid == 1:
9294 
        if ftype == TType.STRUCT:
9295 
          self.ex = TransactionServiceException()
9296 
          self.ex.read(iprot)
9297 
        else:
9298 
          iprot.skip(ftype)
9299 
      else:
9300 
        iprot.skip(ftype)
9301 
      iprot.readFieldEnd()
9302 
    iprot.readStructEnd()
9303 
 
9304 
  def write(self, oprot):
9305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9307 
      return
3064 chandransh 9308 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 9309 
    if self.success is not None:
3064 chandransh 9310 
      oprot.writeFieldBegin('success', TType.I64, 0)
9311 
      oprot.writeI64(self.success)
921 rajveer 9312 
      oprot.writeFieldEnd()
3431 rajveer 9313 
    if self.ex is not None:
921 rajveer 9314 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9315 
      self.ex.write(oprot)
9316 
      oprot.writeFieldEnd()
9317 
    oprot.writeFieldStop()
9318 
    oprot.writeStructEnd()
9319 
 
3431 rajveer 9320 
  def validate(self):
9321 
    return
9322 
 
9323 
 
921 rajveer 9324 
  def __repr__(self):
9325 
    L = ['%s=%r' % (key, value)
9326 
      for key, value in self.__dict__.iteritems()]
9327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9328 
 
9329 
  def __eq__(self, other):
9330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9331 
 
9332 
  def __ne__(self, other):
9333 
    return not (self == other)
9334 
 
3064 chandransh 9335 
class getOrder_args:
921 rajveer 9336 
  """
9337 
  Attributes:
3064 chandransh 9338 
   - id
921 rajveer 9339 
  """
9340 
 
9341 
  thrift_spec = (
9342 
    None, # 0
3064 chandransh 9343 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 9344 
  )
9345 
 
3064 chandransh 9346 
  def __init__(self, id=None,):
9347 
    self.id = id
921 rajveer 9348 
 
9349 
  def read(self, iprot):
9350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9352 
      return
9353 
    iprot.readStructBegin()
9354 
    while True:
9355 
      (fname, ftype, fid) = iprot.readFieldBegin()
9356 
      if ftype == TType.STOP:
9357 
        break
9358 
      if fid == 1:
9359 
        if ftype == TType.I64:
3064 chandransh 9360 
          self.id = iprot.readI64();
921 rajveer 9361 
        else:
9362 
          iprot.skip(ftype)
9363 
      else:
9364 
        iprot.skip(ftype)
9365 
      iprot.readFieldEnd()
9366 
    iprot.readStructEnd()
9367 
 
9368 
  def write(self, oprot):
9369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9371 
      return
3064 chandransh 9372 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 9373 
    if self.id is not None:
3064 chandransh 9374 
      oprot.writeFieldBegin('id', TType.I64, 1)
9375 
      oprot.writeI64(self.id)
921 rajveer 9376 
      oprot.writeFieldEnd()
9377 
    oprot.writeFieldStop()
9378 
    oprot.writeStructEnd()
9379 
 
3431 rajveer 9380 
  def validate(self):
9381 
    return
9382 
 
9383 
 
921 rajveer 9384 
  def __repr__(self):
9385 
    L = ['%s=%r' % (key, value)
9386 
      for key, value in self.__dict__.iteritems()]
9387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9388 
 
9389 
  def __eq__(self, other):
9390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9391 
 
9392 
  def __ne__(self, other):
9393 
    return not (self == other)
9394 
 
3064 chandransh 9395 
class getOrder_result:
921 rajveer 9396 
  """
9397 
  Attributes:
9398 
   - success
9399 
   - ex
9400 
  """
9401 
 
9402 
  thrift_spec = (
3064 chandransh 9403 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 9404 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9405 
  )
9406 
 
9407 
  def __init__(self, success=None, ex=None,):
9408 
    self.success = success
9409 
    self.ex = ex
9410 
 
9411 
  def read(self, iprot):
9412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9414 
      return
9415 
    iprot.readStructBegin()
9416 
    while True:
9417 
      (fname, ftype, fid) = iprot.readFieldBegin()
9418 
      if ftype == TType.STOP:
9419 
        break
9420 
      if fid == 0:
3064 chandransh 9421 
        if ftype == TType.STRUCT:
9422 
          self.success = Order()
9423 
          self.success.read(iprot)
921 rajveer 9424 
        else:
9425 
          iprot.skip(ftype)
9426 
      elif fid == 1:
9427 
        if ftype == TType.STRUCT:
9428 
          self.ex = TransactionServiceException()
9429 
          self.ex.read(iprot)
9430 
        else:
9431 
          iprot.skip(ftype)
9432 
      else:
9433 
        iprot.skip(ftype)
9434 
      iprot.readFieldEnd()
9435 
    iprot.readStructEnd()
9436 
 
9437 
  def write(self, oprot):
9438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9440 
      return
3064 chandransh 9441 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 9442 
    if self.success is not None:
3064 chandransh 9443 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9444 
      self.success.write(oprot)
921 rajveer 9445 
      oprot.writeFieldEnd()
3431 rajveer 9446 
    if self.ex is not None:
921 rajveer 9447 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9448 
      self.ex.write(oprot)
9449 
      oprot.writeFieldEnd()
9450 
    oprot.writeFieldStop()
9451 
    oprot.writeStructEnd()
9452 
 
3431 rajveer 9453 
  def validate(self):
9454 
    return
9455 
 
9456 
 
921 rajveer 9457 
  def __repr__(self):
9458 
    L = ['%s=%r' % (key, value)
9459 
      for key, value in self.__dict__.iteritems()]
9460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9461 
 
9462 
  def __eq__(self, other):
9463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9464 
 
9465 
  def __ne__(self, other):
9466 
    return not (self == other)
9467 
 
3064 chandransh 9468 
class getLineItemsForOrder_args:
94 ashish 9469 
  """
9470 
  Attributes:
3064 chandransh 9471 
   - orderId
94 ashish 9472 
  """
9473 
 
9474 
  thrift_spec = (
9475 
    None, # 0
3064 chandransh 9476 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 9477 
  )
9478 
 
3064 chandransh 9479 
  def __init__(self, orderId=None,):
9480 
    self.orderId = orderId
94 ashish 9481 
 
9482 
  def read(self, iprot):
9483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9485 
      return
9486 
    iprot.readStructBegin()
9487 
    while True:
9488 
      (fname, ftype, fid) = iprot.readFieldBegin()
9489 
      if ftype == TType.STOP:
9490 
        break
9491 
      if fid == 1:
9492 
        if ftype == TType.I64:
3064 chandransh 9493 
          self.orderId = iprot.readI64();
94 ashish 9494 
        else:
9495 
          iprot.skip(ftype)
9496 
      else:
9497 
        iprot.skip(ftype)
9498 
      iprot.readFieldEnd()
9499 
    iprot.readStructEnd()
9500 
 
9501 
  def write(self, oprot):
9502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9504 
      return
3064 chandransh 9505 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 9506 
    if self.orderId is not None:
3064 chandransh 9507 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9508 
      oprot.writeI64(self.orderId)
94 ashish 9509 
      oprot.writeFieldEnd()
9510 
    oprot.writeFieldStop()
9511 
    oprot.writeStructEnd()
9512 
 
3431 rajveer 9513 
  def validate(self):
9514 
    return
9515 
 
9516 
 
94 ashish 9517 
  def __repr__(self):
9518 
    L = ['%s=%r' % (key, value)
9519 
      for key, value in self.__dict__.iteritems()]
9520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9521 
 
9522 
  def __eq__(self, other):
9523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9524 
 
9525 
  def __ne__(self, other):
9526 
    return not (self == other)
9527 
 
3064 chandransh 9528 
class getLineItemsForOrder_result:
94 ashish 9529 
  """
9530 
  Attributes:
9531 
   - success
9532 
   - ex
9533 
  """
9534 
 
9535 
  thrift_spec = (
3064 chandransh 9536 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 9537 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9538 
  )
9539 
 
9540 
  def __init__(self, success=None, ex=None,):
9541 
    self.success = success
9542 
    self.ex = ex
9543 
 
9544 
  def read(self, iprot):
9545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9547 
      return
9548 
    iprot.readStructBegin()
9549 
    while True:
9550 
      (fname, ftype, fid) = iprot.readFieldBegin()
9551 
      if ftype == TType.STOP:
9552 
        break
9553 
      if fid == 0:
483 rajveer 9554 
        if ftype == TType.LIST:
9555 
          self.success = []
5031 varun.gupt 9556 
          (_etype164, _size161) = iprot.readListBegin()
9557 
          for _i165 in xrange(_size161):
9558 
            _elem166 = LineItem()
9559 
            _elem166.read(iprot)
9560 
            self.success.append(_elem166)
483 rajveer 9561 
          iprot.readListEnd()
94 ashish 9562 
        else:
9563 
          iprot.skip(ftype)
9564 
      elif fid == 1:
9565 
        if ftype == TType.STRUCT:
9566 
          self.ex = TransactionServiceException()
9567 
          self.ex.read(iprot)
9568 
        else:
9569 
          iprot.skip(ftype)
9570 
      else:
9571 
        iprot.skip(ftype)
9572 
      iprot.readFieldEnd()
9573 
    iprot.readStructEnd()
9574 
 
9575 
  def write(self, oprot):
9576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9578 
      return
3064 chandransh 9579 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 9580 
    if self.success is not None:
483 rajveer 9581 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9582 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9583 
      for iter167 in self.success:
9584 
        iter167.write(oprot)
483 rajveer 9585 
      oprot.writeListEnd()
94 ashish 9586 
      oprot.writeFieldEnd()
3431 rajveer 9587 
    if self.ex is not None:
94 ashish 9588 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9589 
      self.ex.write(oprot)
9590 
      oprot.writeFieldEnd()
9591 
    oprot.writeFieldStop()
9592 
    oprot.writeStructEnd()
9593 
 
3431 rajveer 9594 
  def validate(self):
9595 
    return
9596 
 
9597 
 
94 ashish 9598 
  def __repr__(self):
9599 
    L = ['%s=%r' % (key, value)
9600 
      for key, value in self.__dict__.iteritems()]
9601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9602 
 
9603 
  def __eq__(self, other):
9604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9605 
 
9606 
  def __ne__(self, other):
9607 
    return not (self == other)
9608 
 
4999 phani.kuma 9609 
class getOrderList_args:
9610 
  """
9611 
  Attributes:
9612 
   - order_ids
9613 
  """
9614 
 
9615 
  thrift_spec = (
9616 
    None, # 0
9617 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
9618 
  )
9619 
 
9620 
  def __init__(self, order_ids=None,):
9621 
    self.order_ids = order_ids
9622 
 
9623 
  def read(self, iprot):
9624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9626 
      return
9627 
    iprot.readStructBegin()
9628 
    while True:
9629 
      (fname, ftype, fid) = iprot.readFieldBegin()
9630 
      if ftype == TType.STOP:
9631 
        break
9632 
      if fid == 1:
9633 
        if ftype == TType.LIST:
9634 
          self.order_ids = []
5031 varun.gupt 9635 
          (_etype171, _size168) = iprot.readListBegin()
9636 
          for _i172 in xrange(_size168):
9637 
            _elem173 = iprot.readI64();
9638 
            self.order_ids.append(_elem173)
4999 phani.kuma 9639 
          iprot.readListEnd()
9640 
        else:
9641 
          iprot.skip(ftype)
9642 
      else:
9643 
        iprot.skip(ftype)
9644 
      iprot.readFieldEnd()
9645 
    iprot.readStructEnd()
9646 
 
9647 
  def write(self, oprot):
9648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9650 
      return
9651 
    oprot.writeStructBegin('getOrderList_args')
9652 
    if self.order_ids is not None:
9653 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
9654 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
5031 varun.gupt 9655 
      for iter174 in self.order_ids:
9656 
        oprot.writeI64(iter174)
4999 phani.kuma 9657 
      oprot.writeListEnd()
9658 
      oprot.writeFieldEnd()
9659 
    oprot.writeFieldStop()
9660 
    oprot.writeStructEnd()
9661 
 
9662 
  def validate(self):
9663 
    return
9664 
 
9665 
 
9666 
  def __repr__(self):
9667 
    L = ['%s=%r' % (key, value)
9668 
      for key, value in self.__dict__.iteritems()]
9669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9670 
 
9671 
  def __eq__(self, other):
9672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9673 
 
9674 
  def __ne__(self, other):
9675 
    return not (self == other)
9676 
 
9677 
class getOrderList_result:
9678 
  """
9679 
  Attributes:
9680 
   - success
9681 
  """
9682 
 
9683 
  thrift_spec = (
9684 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9685 
  )
9686 
 
9687 
  def __init__(self, success=None,):
9688 
    self.success = success
9689 
 
9690 
  def read(self, iprot):
9691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9693 
      return
9694 
    iprot.readStructBegin()
9695 
    while True:
9696 
      (fname, ftype, fid) = iprot.readFieldBegin()
9697 
      if ftype == TType.STOP:
9698 
        break
9699 
      if fid == 0:
9700 
        if ftype == TType.LIST:
9701 
          self.success = []
5031 varun.gupt 9702 
          (_etype178, _size175) = iprot.readListBegin()
9703 
          for _i179 in xrange(_size175):
9704 
            _elem180 = Order()
9705 
            _elem180.read(iprot)
9706 
            self.success.append(_elem180)
4999 phani.kuma 9707 
          iprot.readListEnd()
9708 
        else:
9709 
          iprot.skip(ftype)
9710 
      else:
9711 
        iprot.skip(ftype)
9712 
      iprot.readFieldEnd()
9713 
    iprot.readStructEnd()
9714 
 
9715 
  def write(self, oprot):
9716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9718 
      return
9719 
    oprot.writeStructBegin('getOrderList_result')
9720 
    if self.success is not None:
9721 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9722 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9723 
      for iter181 in self.success:
9724 
        iter181.write(oprot)
4999 phani.kuma 9725 
      oprot.writeListEnd()
9726 
      oprot.writeFieldEnd()
9727 
    oprot.writeFieldStop()
9728 
    oprot.writeStructEnd()
9729 
 
9730 
  def validate(self):
9731 
    return
9732 
 
9733 
 
9734 
  def __repr__(self):
9735 
    L = ['%s=%r' % (key, value)
9736 
      for key, value in self.__dict__.iteritems()]
9737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9738 
 
9739 
  def __eq__(self, other):
9740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9741 
 
9742 
  def __ne__(self, other):
9743 
    return not (self == other)
9744 
 
3064 chandransh 9745 
class getOrderForCustomer_args:
94 ashish 9746 
  """
9747 
  Attributes:
3064 chandransh 9748 
   - orderId
483 rajveer 9749 
   - customerId
94 ashish 9750 
  """
9751 
 
9752 
  thrift_spec = (
9753 
    None, # 0
3064 chandransh 9754 
    (1, TType.I64, 'orderId', None, None, ), # 1
9755 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 9756 
  )
9757 
 
3064 chandransh 9758 
  def __init__(self, orderId=None, customerId=None,):
9759 
    self.orderId = orderId
483 rajveer 9760 
    self.customerId = customerId
94 ashish 9761 
 
9762 
  def read(self, iprot):
9763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9765 
      return
9766 
    iprot.readStructBegin()
9767 
    while True:
9768 
      (fname, ftype, fid) = iprot.readFieldBegin()
9769 
      if ftype == TType.STOP:
9770 
        break
9771 
      if fid == 1:
9772 
        if ftype == TType.I64:
3064 chandransh 9773 
          self.orderId = iprot.readI64();
94 ashish 9774 
        else:
9775 
          iprot.skip(ftype)
9776 
      elif fid == 2:
9777 
        if ftype == TType.I64:
3064 chandransh 9778 
          self.customerId = iprot.readI64();
94 ashish 9779 
        else:
9780 
          iprot.skip(ftype)
9781 
      else:
9782 
        iprot.skip(ftype)
9783 
      iprot.readFieldEnd()
9784 
    iprot.readStructEnd()
9785 
 
9786 
  def write(self, oprot):
9787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9789 
      return
3064 chandransh 9790 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 9791 
    if self.orderId is not None:
3064 chandransh 9792 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9793 
      oprot.writeI64(self.orderId)
9794 
      oprot.writeFieldEnd()
3431 rajveer 9795 
    if self.customerId is not None:
3064 chandransh 9796 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 9797 
      oprot.writeI64(self.customerId)
94 ashish 9798 
      oprot.writeFieldEnd()
9799 
    oprot.writeFieldStop()
9800 
    oprot.writeStructEnd()
9801 
 
3431 rajveer 9802 
  def validate(self):
9803 
    return
9804 
 
9805 
 
94 ashish 9806 
  def __repr__(self):
9807 
    L = ['%s=%r' % (key, value)
9808 
      for key, value in self.__dict__.iteritems()]
9809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9810 
 
9811 
  def __eq__(self, other):
9812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9813 
 
9814 
  def __ne__(self, other):
9815 
    return not (self == other)
9816 
 
3064 chandransh 9817 
class getOrderForCustomer_result:
94 ashish 9818 
  """
9819 
  Attributes:
9820 
   - success
9821 
   - ex
9822 
  """
9823 
 
9824 
  thrift_spec = (
3064 chandransh 9825 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 9826 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9827 
  )
9828 
 
9829 
  def __init__(self, success=None, ex=None,):
9830 
    self.success = success
9831 
    self.ex = ex
9832 
 
9833 
  def read(self, iprot):
9834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9836 
      return
9837 
    iprot.readStructBegin()
9838 
    while True:
9839 
      (fname, ftype, fid) = iprot.readFieldBegin()
9840 
      if ftype == TType.STOP:
9841 
        break
9842 
      if fid == 0:
3064 chandransh 9843 
        if ftype == TType.STRUCT:
9844 
          self.success = Order()
9845 
          self.success.read(iprot)
94 ashish 9846 
        else:
9847 
          iprot.skip(ftype)
9848 
      elif fid == 1:
9849 
        if ftype == TType.STRUCT:
9850 
          self.ex = TransactionServiceException()
9851 
          self.ex.read(iprot)
9852 
        else:
9853 
          iprot.skip(ftype)
9854 
      else:
9855 
        iprot.skip(ftype)
9856 
      iprot.readFieldEnd()
9857 
    iprot.readStructEnd()
9858 
 
9859 
  def write(self, oprot):
9860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9862 
      return
3064 chandransh 9863 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 9864 
    if self.success is not None:
3064 chandransh 9865 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9866 
      self.success.write(oprot)
94 ashish 9867 
      oprot.writeFieldEnd()
3431 rajveer 9868 
    if self.ex is not None:
94 ashish 9869 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9870 
      self.ex.write(oprot)
9871 
      oprot.writeFieldEnd()
9872 
    oprot.writeFieldStop()
9873 
    oprot.writeStructEnd()
9874 
 
3431 rajveer 9875 
  def validate(self):
9876 
    return
9877 
 
9878 
 
94 ashish 9879 
  def __repr__(self):
9880 
    L = ['%s=%r' % (key, value)
9881 
      for key, value in self.__dict__.iteritems()]
9882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9883 
 
9884 
  def __eq__(self, other):
9885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9886 
 
9887 
  def __ne__(self, other):
9888 
    return not (self == other)
9889 
 
3064 chandransh 9890 
class getAlerts_args:
94 ashish 9891 
  """
9892 
  Attributes:
4394 rajveer 9893 
   - type
4444 rajveer 9894 
   - warehouseId
4394 rajveer 9895 
   - status
9896 
   - timestamp
94 ashish 9897 
  """
9898 
 
9899 
  thrift_spec = (
9900 
    None, # 0
4394 rajveer 9901 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9902 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9903 
    (3, TType.I64, 'status', None, None, ), # 3
9904 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 9905 
  )
9906 
 
4444 rajveer 9907 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 9908 
    self.type = type
4444 rajveer 9909 
    self.warehouseId = warehouseId
4394 rajveer 9910 
    self.status = status
9911 
    self.timestamp = timestamp
94 ashish 9912 
 
9913 
  def read(self, iprot):
9914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9916 
      return
9917 
    iprot.readStructBegin()
9918 
    while True:
9919 
      (fname, ftype, fid) = iprot.readFieldBegin()
9920 
      if ftype == TType.STOP:
9921 
        break
9922 
      if fid == 1:
3064 chandransh 9923 
        if ftype == TType.I64:
4394 rajveer 9924 
          self.type = iprot.readI64();
94 ashish 9925 
        else:
9926 
          iprot.skip(ftype)
3064 chandransh 9927 
      elif fid == 2:
4394 rajveer 9928 
        if ftype == TType.I64:
4444 rajveer 9929 
          self.warehouseId = iprot.readI64();
3064 chandransh 9930 
        else:
9931 
          iprot.skip(ftype)
4394 rajveer 9932 
      elif fid == 3:
9933 
        if ftype == TType.I64:
4444 rajveer 9934 
          self.status = iprot.readI64();
9935 
        else:
9936 
          iprot.skip(ftype)
9937 
      elif fid == 4:
9938 
        if ftype == TType.I64:
4394 rajveer 9939 
          self.timestamp = iprot.readI64();
9940 
        else:
9941 
          iprot.skip(ftype)
94 ashish 9942 
      else:
9943 
        iprot.skip(ftype)
9944 
      iprot.readFieldEnd()
9945 
    iprot.readStructEnd()
9946 
 
9947 
  def write(self, oprot):
9948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9950 
      return
3064 chandransh 9951 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 9952 
    if self.type is not None:
9953 
      oprot.writeFieldBegin('type', TType.I64, 1)
9954 
      oprot.writeI64(self.type)
94 ashish 9955 
      oprot.writeFieldEnd()
4444 rajveer 9956 
    if self.warehouseId is not None:
9957 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9958 
      oprot.writeI64(self.warehouseId)
9959 
      oprot.writeFieldEnd()
4394 rajveer 9960 
    if self.status is not None:
4444 rajveer 9961 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 9962 
      oprot.writeI64(self.status)
3064 chandransh 9963 
      oprot.writeFieldEnd()
4394 rajveer 9964 
    if self.timestamp is not None:
4444 rajveer 9965 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 9966 
      oprot.writeI64(self.timestamp)
9967 
      oprot.writeFieldEnd()
94 ashish 9968 
    oprot.writeFieldStop()
9969 
    oprot.writeStructEnd()
9970 
 
3431 rajveer 9971 
  def validate(self):
9972 
    return
9973 
 
9974 
 
94 ashish 9975 
  def __repr__(self):
9976 
    L = ['%s=%r' % (key, value)
9977 
      for key, value in self.__dict__.iteritems()]
9978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9979 
 
9980 
  def __eq__(self, other):
9981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9982 
 
9983 
  def __ne__(self, other):
9984 
    return not (self == other)
9985 
 
3064 chandransh 9986 
class getAlerts_result:
94 ashish 9987 
  """
9988 
  Attributes:
9989 
   - success
9990 
  """
9991 
 
9992 
  thrift_spec = (
3064 chandransh 9993 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 9994 
  )
9995 
 
3064 chandransh 9996 
  def __init__(self, success=None,):
94 ashish 9997 
    self.success = success
9998 
 
9999 
  def read(self, iprot):
10000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10002 
      return
10003 
    iprot.readStructBegin()
10004 
    while True:
10005 
      (fname, ftype, fid) = iprot.readFieldBegin()
10006 
      if ftype == TType.STOP:
10007 
        break
10008 
      if fid == 0:
3064 chandransh 10009 
        if ftype == TType.LIST:
10010 
          self.success = []
5031 varun.gupt 10011 
          (_etype185, _size182) = iprot.readListBegin()
10012 
          for _i186 in xrange(_size182):
10013 
            _elem187 = Alert()
10014 
            _elem187.read(iprot)
10015 
            self.success.append(_elem187)
3064 chandransh 10016 
          iprot.readListEnd()
94 ashish 10017 
        else:
10018 
          iprot.skip(ftype)
10019 
      else:
10020 
        iprot.skip(ftype)
10021 
      iprot.readFieldEnd()
10022 
    iprot.readStructEnd()
10023 
 
10024 
  def write(self, oprot):
10025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10027 
      return
3064 chandransh 10028 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 10029 
    if self.success is not None:
3064 chandransh 10030 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10031 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10032 
      for iter188 in self.success:
10033 
        iter188.write(oprot)
3064 chandransh 10034 
      oprot.writeListEnd()
94 ashish 10035 
      oprot.writeFieldEnd()
10036 
    oprot.writeFieldStop()
10037 
    oprot.writeStructEnd()
10038 
 
3431 rajveer 10039 
  def validate(self):
10040 
    return
10041 
 
10042 
 
94 ashish 10043 
  def __repr__(self):
10044 
    L = ['%s=%r' % (key, value)
10045 
      for key, value in self.__dict__.iteritems()]
10046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10047 
 
10048 
  def __eq__(self, other):
10049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10050 
 
10051 
  def __ne__(self, other):
10052 
    return not (self == other)
10053 
 
4394 rajveer 10054 
class addAlert_args:
94 ashish 10055 
  """
10056 
  Attributes:
3064 chandransh 10057 
   - type
4444 rajveer 10058 
   - warehouseId
4394 rajveer 10059 
   - description
94 ashish 10060 
  """
10061 
 
10062 
  thrift_spec = (
10063 
    None, # 0
4394 rajveer 10064 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10065 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10066 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10067 
  )
10068 
 
4444 rajveer 10069 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 10070 
    self.type = type
4444 rajveer 10071 
    self.warehouseId = warehouseId
4394 rajveer 10072 
    self.description = description
94 ashish 10073 
 
10074 
  def read(self, iprot):
10075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10077 
      return
10078 
    iprot.readStructBegin()
10079 
    while True:
10080 
      (fname, ftype, fid) = iprot.readFieldBegin()
10081 
      if ftype == TType.STOP:
10082 
        break
10083 
      if fid == 1:
10084 
        if ftype == TType.I64:
4394 rajveer 10085 
          self.type = iprot.readI64();
94 ashish 10086 
        else:
10087 
          iprot.skip(ftype)
3064 chandransh 10088 
      elif fid == 2:
4444 rajveer 10089 
        if ftype == TType.I64:
10090 
          self.warehouseId = iprot.readI64();
10091 
        else:
10092 
          iprot.skip(ftype)
10093 
      elif fid == 3:
3064 chandransh 10094 
        if ftype == TType.STRING:
4394 rajveer 10095 
          self.description = iprot.readString();
3064 chandransh 10096 
        else:
10097 
          iprot.skip(ftype)
94 ashish 10098 
      else:
10099 
        iprot.skip(ftype)
10100 
      iprot.readFieldEnd()
10101 
    iprot.readStructEnd()
10102 
 
10103 
  def write(self, oprot):
10104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10106 
      return
4394 rajveer 10107 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 10108 
    if self.type is not None:
4394 rajveer 10109 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 10110 
      oprot.writeI64(self.type)
10111 
      oprot.writeFieldEnd()
4444 rajveer 10112 
    if self.warehouseId is not None:
10113 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10114 
      oprot.writeI64(self.warehouseId)
10115 
      oprot.writeFieldEnd()
4394 rajveer 10116 
    if self.description is not None:
4444 rajveer 10117 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 10118 
      oprot.writeString(self.description)
3064 chandransh 10119 
      oprot.writeFieldEnd()
94 ashish 10120 
    oprot.writeFieldStop()
10121 
    oprot.writeStructEnd()
10122 
 
3431 rajveer 10123 
  def validate(self):
10124 
    return
10125 
 
10126 
 
94 ashish 10127 
  def __repr__(self):
10128 
    L = ['%s=%r' % (key, value)
10129 
      for key, value in self.__dict__.iteritems()]
10130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10131 
 
10132 
  def __eq__(self, other):
10133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10134 
 
10135 
  def __ne__(self, other):
10136 
    return not (self == other)
10137 
 
4394 rajveer 10138 
class addAlert_result:
3064 chandransh 10139 
 
10140 
  thrift_spec = (
10141 
  )
10142 
 
10143 
  def read(self, iprot):
10144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10146 
      return
10147 
    iprot.readStructBegin()
10148 
    while True:
10149 
      (fname, ftype, fid) = iprot.readFieldBegin()
10150 
      if ftype == TType.STOP:
10151 
        break
10152 
      else:
10153 
        iprot.skip(ftype)
10154 
      iprot.readFieldEnd()
10155 
    iprot.readStructEnd()
10156 
 
10157 
  def write(self, oprot):
10158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10160 
      return
4394 rajveer 10161 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 10162 
    oprot.writeFieldStop()
10163 
    oprot.writeStructEnd()
10164 
 
3431 rajveer 10165 
  def validate(self):
10166 
    return
10167 
 
10168 
 
3064 chandransh 10169 
  def __repr__(self):
10170 
    L = ['%s=%r' % (key, value)
10171 
      for key, value in self.__dict__.iteritems()]
10172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10173 
 
10174 
  def __eq__(self, other):
10175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10176 
 
10177 
  def __ne__(self, other):
10178 
    return not (self == other)
10179 
 
4444 rajveer 10180 
class markAlertsAsSeen_args:
10181 
  """
10182 
  Attributes:
10183 
   - warehouseId
10184 
  """
10185 
 
10186 
  thrift_spec = (
10187 
    None, # 0
10188 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10189 
  )
10190 
 
10191 
  def __init__(self, warehouseId=None,):
10192 
    self.warehouseId = warehouseId
10193 
 
10194 
  def read(self, iprot):
10195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10197 
      return
10198 
    iprot.readStructBegin()
10199 
    while True:
10200 
      (fname, ftype, fid) = iprot.readFieldBegin()
10201 
      if ftype == TType.STOP:
10202 
        break
10203 
      if fid == 1:
10204 
        if ftype == TType.I64:
10205 
          self.warehouseId = iprot.readI64();
10206 
        else:
10207 
          iprot.skip(ftype)
10208 
      else:
10209 
        iprot.skip(ftype)
10210 
      iprot.readFieldEnd()
10211 
    iprot.readStructEnd()
10212 
 
10213 
  def write(self, oprot):
10214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10216 
      return
10217 
    oprot.writeStructBegin('markAlertsAsSeen_args')
10218 
    if self.warehouseId is not None:
10219 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10220 
      oprot.writeI64(self.warehouseId)
10221 
      oprot.writeFieldEnd()
10222 
    oprot.writeFieldStop()
10223 
    oprot.writeStructEnd()
10224 
 
10225 
  def validate(self):
10226 
    return
10227 
 
10228 
 
10229 
  def __repr__(self):
10230 
    L = ['%s=%r' % (key, value)
10231 
      for key, value in self.__dict__.iteritems()]
10232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10233 
 
10234 
  def __eq__(self, other):
10235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10236 
 
10237 
  def __ne__(self, other):
10238 
    return not (self == other)
10239 
 
10240 
class markAlertsAsSeen_result:
10241 
 
10242 
  thrift_spec = (
10243 
  )
10244 
 
10245 
  def read(self, iprot):
10246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10248 
      return
10249 
    iprot.readStructBegin()
10250 
    while True:
10251 
      (fname, ftype, fid) = iprot.readFieldBegin()
10252 
      if ftype == TType.STOP:
10253 
        break
10254 
      else:
10255 
        iprot.skip(ftype)
10256 
      iprot.readFieldEnd()
10257 
    iprot.readStructEnd()
10258 
 
10259 
  def write(self, oprot):
10260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10262 
      return
10263 
    oprot.writeStructBegin('markAlertsAsSeen_result')
10264 
    oprot.writeFieldStop()
10265 
    oprot.writeStructEnd()
10266 
 
10267 
  def validate(self):
10268 
    return
10269 
 
10270 
 
10271 
  def __repr__(self):
10272 
    L = ['%s=%r' % (key, value)
10273 
      for key, value in self.__dict__.iteritems()]
10274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10275 
 
10276 
  def __eq__(self, other):
10277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10278 
 
10279 
  def __ne__(self, other):
10280 
    return not (self == other)
10281 
 
3064 chandransh 10282 
class getValidOrderCount_args:
10283 
 
10284 
  thrift_spec = (
10285 
  )
10286 
 
10287 
  def read(self, iprot):
10288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10290 
      return
10291 
    iprot.readStructBegin()
10292 
    while True:
10293 
      (fname, ftype, fid) = iprot.readFieldBegin()
10294 
      if ftype == TType.STOP:
10295 
        break
10296 
      else:
10297 
        iprot.skip(ftype)
10298 
      iprot.readFieldEnd()
10299 
    iprot.readStructEnd()
10300 
 
10301 
  def write(self, oprot):
10302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10304 
      return
10305 
    oprot.writeStructBegin('getValidOrderCount_args')
10306 
    oprot.writeFieldStop()
10307 
    oprot.writeStructEnd()
10308 
 
3431 rajveer 10309 
  def validate(self):
10310 
    return
10311 
 
10312 
 
3064 chandransh 10313 
  def __repr__(self):
10314 
    L = ['%s=%r' % (key, value)
10315 
      for key, value in self.__dict__.iteritems()]
10316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10317 
 
10318 
  def __eq__(self, other):
10319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10320 
 
10321 
  def __ne__(self, other):
10322 
    return not (self == other)
10323 
 
10324 
class getValidOrderCount_result:
94 ashish 10325 
  """
10326 
  Attributes:
10327 
   - success
10328 
  """
10329 
 
10330 
  thrift_spec = (
3064 chandransh 10331 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10332 
  )
10333 
 
3064 chandransh 10334 
  def __init__(self, success=None,):
94 ashish 10335 
    self.success = success
10336 
 
10337 
  def read(self, iprot):
10338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10340 
      return
10341 
    iprot.readStructBegin()
10342 
    while True:
10343 
      (fname, ftype, fid) = iprot.readFieldBegin()
10344 
      if ftype == TType.STOP:
10345 
        break
10346 
      if fid == 0:
3064 chandransh 10347 
        if ftype == TType.I64:
10348 
          self.success = iprot.readI64();
94 ashish 10349 
        else:
10350 
          iprot.skip(ftype)
10351 
      else:
10352 
        iprot.skip(ftype)
10353 
      iprot.readFieldEnd()
10354 
    iprot.readStructEnd()
10355 
 
10356 
  def write(self, oprot):
10357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10359 
      return
3064 chandransh 10360 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 10361 
    if self.success is not None:
3064 chandransh 10362 
      oprot.writeFieldBegin('success', TType.I64, 0)
10363 
      oprot.writeI64(self.success)
94 ashish 10364 
      oprot.writeFieldEnd()
10365 
    oprot.writeFieldStop()
10366 
    oprot.writeStructEnd()
10367 
 
3431 rajveer 10368 
  def validate(self):
10369 
    return
10370 
 
10371 
 
94 ashish 10372 
  def __repr__(self):
10373 
    L = ['%s=%r' % (key, value)
10374 
      for key, value in self.__dict__.iteritems()]
10375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10376 
 
10377 
  def __eq__(self, other):
10378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10379 
 
10380 
  def __ne__(self, other):
10381 
    return not (self == other)
10382 
 
3064 chandransh 10383 
class getNoOfCustomersWithSuccessfulTransaction_args:
10384 
 
10385 
  thrift_spec = (
10386 
  )
10387 
 
10388 
  def read(self, iprot):
10389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10391 
      return
10392 
    iprot.readStructBegin()
10393 
    while True:
10394 
      (fname, ftype, fid) = iprot.readFieldBegin()
10395 
      if ftype == TType.STOP:
10396 
        break
10397 
      else:
10398 
        iprot.skip(ftype)
10399 
      iprot.readFieldEnd()
10400 
    iprot.readStructEnd()
10401 
 
10402 
  def write(self, oprot):
10403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10405 
      return
10406 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
10407 
    oprot.writeFieldStop()
10408 
    oprot.writeStructEnd()
10409 
 
3431 rajveer 10410 
  def validate(self):
10411 
    return
10412 
 
10413 
 
3064 chandransh 10414 
  def __repr__(self):
10415 
    L = ['%s=%r' % (key, value)
10416 
      for key, value in self.__dict__.iteritems()]
10417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10418 
 
10419 
  def __eq__(self, other):
10420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10421 
 
10422 
  def __ne__(self, other):
10423 
    return not (self == other)
10424 
 
10425 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 10426 
  """
10427 
  Attributes:
3064 chandransh 10428 
   - success
94 ashish 10429 
  """
10430 
 
10431 
  thrift_spec = (
3064 chandransh 10432 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10433 
  )
10434 
 
3064 chandransh 10435 
  def __init__(self, success=None,):
10436 
    self.success = success
94 ashish 10437 
 
10438 
  def read(self, iprot):
10439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10441 
      return
10442 
    iprot.readStructBegin()
10443 
    while True:
10444 
      (fname, ftype, fid) = iprot.readFieldBegin()
10445 
      if ftype == TType.STOP:
10446 
        break
3064 chandransh 10447 
      if fid == 0:
94 ashish 10448 
        if ftype == TType.I64:
3064 chandransh 10449 
          self.success = iprot.readI64();
94 ashish 10450 
        else:
10451 
          iprot.skip(ftype)
10452 
      else:
10453 
        iprot.skip(ftype)
10454 
      iprot.readFieldEnd()
10455 
    iprot.readStructEnd()
10456 
 
10457 
  def write(self, oprot):
10458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10460 
      return
3064 chandransh 10461 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 10462 
    if self.success is not None:
3064 chandransh 10463 
      oprot.writeFieldBegin('success', TType.I64, 0)
10464 
      oprot.writeI64(self.success)
94 ashish 10465 
      oprot.writeFieldEnd()
10466 
    oprot.writeFieldStop()
10467 
    oprot.writeStructEnd()
10468 
 
3431 rajveer 10469 
  def validate(self):
10470 
    return
10471 
 
10472 
 
94 ashish 10473 
  def __repr__(self):
10474 
    L = ['%s=%r' % (key, value)
10475 
      for key, value in self.__dict__.iteritems()]
10476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10477 
 
10478 
  def __eq__(self, other):
10479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10480 
 
10481 
  def __ne__(self, other):
10482 
    return not (self == other)
10483 
 
3064 chandransh 10484 
class getValidOrdersAmountRange_args:
10485 
 
10486 
  thrift_spec = (
10487 
  )
10488 
 
10489 
  def read(self, iprot):
10490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10492 
      return
10493 
    iprot.readStructBegin()
10494 
    while True:
10495 
      (fname, ftype, fid) = iprot.readFieldBegin()
10496 
      if ftype == TType.STOP:
10497 
        break
10498 
      else:
10499 
        iprot.skip(ftype)
10500 
      iprot.readFieldEnd()
10501 
    iprot.readStructEnd()
10502 
 
10503 
  def write(self, oprot):
10504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10506 
      return
10507 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
10508 
    oprot.writeFieldStop()
10509 
    oprot.writeStructEnd()
10510 
 
3431 rajveer 10511 
  def validate(self):
10512 
    return
10513 
 
10514 
 
3064 chandransh 10515 
  def __repr__(self):
10516 
    L = ['%s=%r' % (key, value)
10517 
      for key, value in self.__dict__.iteritems()]
10518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10519 
 
10520 
  def __eq__(self, other):
10521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10522 
 
10523 
  def __ne__(self, other):
10524 
    return not (self == other)
10525 
 
10526 
class getValidOrdersAmountRange_result:
94 ashish 10527 
  """
10528 
  Attributes:
10529 
   - success
10530 
  """
10531 
 
10532 
  thrift_spec = (
3064 chandransh 10533 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 10534 
  )
10535 
 
3064 chandransh 10536 
  def __init__(self, success=None,):
94 ashish 10537 
    self.success = success
10538 
 
10539 
  def read(self, iprot):
10540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10542 
      return
10543 
    iprot.readStructBegin()
10544 
    while True:
10545 
      (fname, ftype, fid) = iprot.readFieldBegin()
10546 
      if ftype == TType.STOP:
10547 
        break
10548 
      if fid == 0:
483 rajveer 10549 
        if ftype == TType.LIST:
10550 
          self.success = []
5031 varun.gupt 10551 
          (_etype192, _size189) = iprot.readListBegin()
10552 
          for _i193 in xrange(_size189):
10553 
            _elem194 = iprot.readDouble();
10554 
            self.success.append(_elem194)
483 rajveer 10555 
          iprot.readListEnd()
94 ashish 10556 
        else:
10557 
          iprot.skip(ftype)
10558 
      else:
10559 
        iprot.skip(ftype)
10560 
      iprot.readFieldEnd()
10561 
    iprot.readStructEnd()
10562 
 
10563 
  def write(self, oprot):
10564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10566 
      return
3064 chandransh 10567 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 10568 
    if self.success is not None:
483 rajveer 10569 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 10570 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
5031 varun.gupt 10571 
      for iter195 in self.success:
10572 
        oprot.writeDouble(iter195)
483 rajveer 10573 
      oprot.writeListEnd()
94 ashish 10574 
      oprot.writeFieldEnd()
10575 
    oprot.writeFieldStop()
10576 
    oprot.writeStructEnd()
10577 
 
3431 rajveer 10578 
  def validate(self):
10579 
    return
10580 
 
10581 
 
94 ashish 10582 
  def __repr__(self):
10583 
    L = ['%s=%r' % (key, value)
10584 
      for key, value in self.__dict__.iteritems()]
10585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10586 
 
10587 
  def __eq__(self, other):
10588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10589 
 
10590 
  def __ne__(self, other):
10591 
    return not (self == other)
10592 
 
3064 chandransh 10593 
class getValidOrders_args:
1528 ankur.sing 10594 
  """
10595 
  Attributes:
3064 chandransh 10596 
   - limit
1528 ankur.sing 10597 
  """
10598 
 
10599 
  thrift_spec = (
10600 
    None, # 0
3064 chandransh 10601 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 10602 
  )
10603 
 
3064 chandransh 10604 
  def __init__(self, limit=None,):
10605 
    self.limit = limit
1528 ankur.sing 10606 
 
10607 
  def read(self, iprot):
10608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10610 
      return
10611 
    iprot.readStructBegin()
10612 
    while True:
10613 
      (fname, ftype, fid) = iprot.readFieldBegin()
10614 
      if ftype == TType.STOP:
10615 
        break
10616 
      if fid == 1:
10617 
        if ftype == TType.I64:
3064 chandransh 10618 
          self.limit = iprot.readI64();
1528 ankur.sing 10619 
        else:
10620 
          iprot.skip(ftype)
10621 
      else:
10622 
        iprot.skip(ftype)
10623 
      iprot.readFieldEnd()
10624 
    iprot.readStructEnd()
10625 
 
10626 
  def write(self, oprot):
10627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10629 
      return
3064 chandransh 10630 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 10631 
    if self.limit is not None:
3064 chandransh 10632 
      oprot.writeFieldBegin('limit', TType.I64, 1)
10633 
      oprot.writeI64(self.limit)
1528 ankur.sing 10634 
      oprot.writeFieldEnd()
10635 
    oprot.writeFieldStop()
10636 
    oprot.writeStructEnd()
10637 
 
3431 rajveer 10638 
  def validate(self):
10639 
    return
10640 
 
10641 
 
1528 ankur.sing 10642 
  def __repr__(self):
10643 
    L = ['%s=%r' % (key, value)
10644 
      for key, value in self.__dict__.iteritems()]
10645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10646 
 
10647 
  def __eq__(self, other):
10648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10649 
 
10650 
  def __ne__(self, other):
10651 
    return not (self == other)
10652 
 
3064 chandransh 10653 
class getValidOrders_result:
1528 ankur.sing 10654 
  """
10655 
  Attributes:
10656 
   - success
10657 
  """
10658 
 
10659 
  thrift_spec = (
3064 chandransh 10660 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 10661 
  )
10662 
 
3064 chandransh 10663 
  def __init__(self, success=None,):
1528 ankur.sing 10664 
    self.success = success
10665 
 
10666 
  def read(self, iprot):
10667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10669 
      return
10670 
    iprot.readStructBegin()
10671 
    while True:
10672 
      (fname, ftype, fid) = iprot.readFieldBegin()
10673 
      if ftype == TType.STOP:
10674 
        break
10675 
      if fid == 0:
3064 chandransh 10676 
        if ftype == TType.LIST:
10677 
          self.success = []
5031 varun.gupt 10678 
          (_etype199, _size196) = iprot.readListBegin()
10679 
          for _i200 in xrange(_size196):
10680 
            _elem201 = Order()
10681 
            _elem201.read(iprot)
10682 
            self.success.append(_elem201)
3064 chandransh 10683 
          iprot.readListEnd()
1528 ankur.sing 10684 
        else:
10685 
          iprot.skip(ftype)
10686 
      else:
10687 
        iprot.skip(ftype)
10688 
      iprot.readFieldEnd()
10689 
    iprot.readStructEnd()
10690 
 
10691 
  def write(self, oprot):
10692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10694 
      return
3064 chandransh 10695 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 10696 
    if self.success is not None:
3064 chandransh 10697 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10698 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10699 
      for iter202 in self.success:
10700 
        iter202.write(oprot)
3064 chandransh 10701 
      oprot.writeListEnd()
1528 ankur.sing 10702 
      oprot.writeFieldEnd()
10703 
    oprot.writeFieldStop()
10704 
    oprot.writeStructEnd()
10705 
 
3431 rajveer 10706 
  def validate(self):
10707 
    return
10708 
 
10709 
 
1528 ankur.sing 10710 
  def __repr__(self):
10711 
    L = ['%s=%r' % (key, value)
10712 
      for key, value in self.__dict__.iteritems()]
10713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10714 
 
10715 
  def __eq__(self, other):
10716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10717 
 
10718 
  def __ne__(self, other):
10719 
    return not (self == other)
10720 
 
1220 chandransh 10721 
class batchOrders_args:
10722 
  """
10723 
  Attributes:
10724 
   - warehouseId
10725 
  """
10726 
 
10727 
  thrift_spec = (
10728 
    None, # 0
10729 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10730 
  )
10731 
 
10732 
  def __init__(self, warehouseId=None,):
10733 
    self.warehouseId = warehouseId
10734 
 
10735 
  def read(self, iprot):
10736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10738 
      return
10739 
    iprot.readStructBegin()
10740 
    while True:
10741 
      (fname, ftype, fid) = iprot.readFieldBegin()
10742 
      if ftype == TType.STOP:
10743 
        break
10744 
      if fid == 1:
10745 
        if ftype == TType.I64:
10746 
          self.warehouseId = iprot.readI64();
10747 
        else:
10748 
          iprot.skip(ftype)
10749 
      else:
10750 
        iprot.skip(ftype)
10751 
      iprot.readFieldEnd()
10752 
    iprot.readStructEnd()
10753 
 
10754 
  def write(self, oprot):
10755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10757 
      return
10758 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 10759 
    if self.warehouseId is not None:
1220 chandransh 10760 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10761 
      oprot.writeI64(self.warehouseId)
10762 
      oprot.writeFieldEnd()
10763 
    oprot.writeFieldStop()
10764 
    oprot.writeStructEnd()
10765 
 
3431 rajveer 10766 
  def validate(self):
10767 
    return
10768 
 
10769 
 
1220 chandransh 10770 
  def __repr__(self):
10771 
    L = ['%s=%r' % (key, value)
10772 
      for key, value in self.__dict__.iteritems()]
10773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10774 
 
10775 
  def __eq__(self, other):
10776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10777 
 
10778 
  def __ne__(self, other):
10779 
    return not (self == other)
10780 
 
10781 
class batchOrders_result:
10782 
  """
10783 
  Attributes:
10784 
   - success
10785 
   - ex
10786 
  """
10787 
 
10788 
  thrift_spec = (
10789 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10790 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10791 
  )
10792 
 
10793 
  def __init__(self, success=None, ex=None,):
10794 
    self.success = success
10795 
    self.ex = ex
10796 
 
10797 
  def read(self, iprot):
10798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10800 
      return
10801 
    iprot.readStructBegin()
10802 
    while True:
10803 
      (fname, ftype, fid) = iprot.readFieldBegin()
10804 
      if ftype == TType.STOP:
10805 
        break
10806 
      if fid == 0:
10807 
        if ftype == TType.LIST:
10808 
          self.success = []
5031 varun.gupt 10809 
          (_etype206, _size203) = iprot.readListBegin()
10810 
          for _i207 in xrange(_size203):
10811 
            _elem208 = Order()
10812 
            _elem208.read(iprot)
10813 
            self.success.append(_elem208)
1220 chandransh 10814 
          iprot.readListEnd()
10815 
        else:
10816 
          iprot.skip(ftype)
10817 
      elif fid == 1:
10818 
        if ftype == TType.STRUCT:
10819 
          self.ex = TransactionServiceException()
10820 
          self.ex.read(iprot)
10821 
        else:
10822 
          iprot.skip(ftype)
10823 
      else:
10824 
        iprot.skip(ftype)
10825 
      iprot.readFieldEnd()
10826 
    iprot.readStructEnd()
10827 
 
10828 
  def write(self, oprot):
10829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10831 
      return
10832 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 10833 
    if self.success is not None:
1220 chandransh 10834 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10835 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10836 
      for iter209 in self.success:
10837 
        iter209.write(oprot)
1220 chandransh 10838 
      oprot.writeListEnd()
10839 
      oprot.writeFieldEnd()
3431 rajveer 10840 
    if self.ex is not None:
1220 chandransh 10841 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10842 
      self.ex.write(oprot)
10843 
      oprot.writeFieldEnd()
10844 
    oprot.writeFieldStop()
10845 
    oprot.writeStructEnd()
10846 
 
3431 rajveer 10847 
  def validate(self):
10848 
    return
10849 
 
10850 
 
1220 chandransh 10851 
  def __repr__(self):
10852 
    L = ['%s=%r' % (key, value)
10853 
      for key, value in self.__dict__.iteritems()]
10854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10855 
 
10856 
  def __eq__(self, other):
10857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10858 
 
10859 
  def __ne__(self, other):
10860 
    return not (self == other)
10861 
 
1208 chandransh 10862 
class markOrderAsOutOfStock_args:
10863 
  """
10864 
  Attributes:
10865 
   - orderId
10866 
  """
10867 
 
10868 
  thrift_spec = (
10869 
    None, # 0
10870 
    (1, TType.I64, 'orderId', None, None, ), # 1
10871 
  )
10872 
 
10873 
  def __init__(self, orderId=None,):
10874 
    self.orderId = orderId
10875 
 
10876 
  def read(self, iprot):
10877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10879 
      return
10880 
    iprot.readStructBegin()
10881 
    while True:
10882 
      (fname, ftype, fid) = iprot.readFieldBegin()
10883 
      if ftype == TType.STOP:
10884 
        break
10885 
      if fid == 1:
10886 
        if ftype == TType.I64:
10887 
          self.orderId = iprot.readI64();
10888 
        else:
10889 
          iprot.skip(ftype)
10890 
      else:
10891 
        iprot.skip(ftype)
10892 
      iprot.readFieldEnd()
10893 
    iprot.readStructEnd()
10894 
 
10895 
  def write(self, oprot):
10896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10898 
      return
10899 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 10900 
    if self.orderId is not None:
1208 chandransh 10901 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10902 
      oprot.writeI64(self.orderId)
10903 
      oprot.writeFieldEnd()
10904 
    oprot.writeFieldStop()
10905 
    oprot.writeStructEnd()
10906 
 
3431 rajveer 10907 
  def validate(self):
10908 
    return
10909 
 
10910 
 
1208 chandransh 10911 
  def __repr__(self):
10912 
    L = ['%s=%r' % (key, value)
10913 
      for key, value in self.__dict__.iteritems()]
10914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10915 
 
10916 
  def __eq__(self, other):
10917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10918 
 
10919 
  def __ne__(self, other):
10920 
    return not (self == other)
10921 
 
10922 
class markOrderAsOutOfStock_result:
10923 
  """
10924 
  Attributes:
10925 
   - success
10926 
   - ex
10927 
  """
10928 
 
10929 
  thrift_spec = (
10930 
    (0, TType.BOOL, 'success', None, None, ), # 0
10931 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10932 
  )
10933 
 
10934 
  def __init__(self, success=None, ex=None,):
10935 
    self.success = success
10936 
    self.ex = ex
10937 
 
10938 
  def read(self, iprot):
10939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10941 
      return
10942 
    iprot.readStructBegin()
10943 
    while True:
10944 
      (fname, ftype, fid) = iprot.readFieldBegin()
10945 
      if ftype == TType.STOP:
10946 
        break
10947 
      if fid == 0:
10948 
        if ftype == TType.BOOL:
10949 
          self.success = iprot.readBool();
10950 
        else:
10951 
          iprot.skip(ftype)
10952 
      elif fid == 1:
10953 
        if ftype == TType.STRUCT:
10954 
          self.ex = TransactionServiceException()
10955 
          self.ex.read(iprot)
10956 
        else:
10957 
          iprot.skip(ftype)
10958 
      else:
10959 
        iprot.skip(ftype)
10960 
      iprot.readFieldEnd()
10961 
    iprot.readStructEnd()
10962 
 
10963 
  def write(self, oprot):
10964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10966 
      return
10967 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 10968 
    if self.success is not None:
1208 chandransh 10969 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10970 
      oprot.writeBool(self.success)
10971 
      oprot.writeFieldEnd()
3431 rajveer 10972 
    if self.ex is not None:
1208 chandransh 10973 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10974 
      self.ex.write(oprot)
10975 
      oprot.writeFieldEnd()
10976 
    oprot.writeFieldStop()
10977 
    oprot.writeStructEnd()
10978 
 
3431 rajveer 10979 
  def validate(self):
10980 
    return
10981 
 
10982 
 
1208 chandransh 10983 
  def __repr__(self):
10984 
    L = ['%s=%r' % (key, value)
10985 
      for key, value in self.__dict__.iteritems()]
10986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10987 
 
10988 
  def __eq__(self, other):
10989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10990 
 
10991 
  def __ne__(self, other):
10992 
    return not (self == other)
10993 
 
3064 chandransh 10994 
class verifyOrder_args:
759 chandransh 10995 
  """
10996 
  Attributes:
3064 chandransh 10997 
   - orderId
759 chandransh 10998 
  """
10999 
 
11000 
  thrift_spec = (
11001 
    None, # 0
3064 chandransh 11002 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 11003 
  )
11004 
 
3064 chandransh 11005 
  def __init__(self, orderId=None,):
11006 
    self.orderId = orderId
759 chandransh 11007 
 
11008 
  def read(self, iprot):
11009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11011 
      return
11012 
    iprot.readStructBegin()
11013 
    while True:
11014 
      (fname, ftype, fid) = iprot.readFieldBegin()
11015 
      if ftype == TType.STOP:
11016 
        break
11017 
      if fid == 1:
11018 
        if ftype == TType.I64:
3064 chandransh 11019 
          self.orderId = iprot.readI64();
759 chandransh 11020 
        else:
11021 
          iprot.skip(ftype)
11022 
      else:
11023 
        iprot.skip(ftype)
11024 
      iprot.readFieldEnd()
11025 
    iprot.readStructEnd()
11026 
 
11027 
  def write(self, oprot):
11028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11030 
      return
3064 chandransh 11031 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 11032 
    if self.orderId is not None:
3064 chandransh 11033 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11034 
      oprot.writeI64(self.orderId)
759 chandransh 11035 
      oprot.writeFieldEnd()
11036 
    oprot.writeFieldStop()
11037 
    oprot.writeStructEnd()
11038 
 
3431 rajveer 11039 
  def validate(self):
11040 
    return
11041 
 
11042 
 
759 chandransh 11043 
  def __repr__(self):
11044 
    L = ['%s=%r' % (key, value)
11045 
      for key, value in self.__dict__.iteritems()]
11046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11047 
 
11048 
  def __eq__(self, other):
11049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11050 
 
11051 
  def __ne__(self, other):
11052 
    return not (self == other)
11053 
 
3064 chandransh 11054 
class verifyOrder_result:
759 chandransh 11055 
  """
11056 
  Attributes:
11057 
   - success
11058 
   - ex
11059 
  """
11060 
 
11061 
  thrift_spec = (
11062 
    (0, TType.BOOL, 'success', None, None, ), # 0
11063 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11064 
  )
11065 
 
11066 
  def __init__(self, success=None, ex=None,):
11067 
    self.success = success
11068 
    self.ex = ex
11069 
 
11070 
  def read(self, iprot):
11071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11073 
      return
11074 
    iprot.readStructBegin()
11075 
    while True:
11076 
      (fname, ftype, fid) = iprot.readFieldBegin()
11077 
      if ftype == TType.STOP:
11078 
        break
11079 
      if fid == 0:
11080 
        if ftype == TType.BOOL:
11081 
          self.success = iprot.readBool();
11082 
        else:
11083 
          iprot.skip(ftype)
11084 
      elif fid == 1:
11085 
        if ftype == TType.STRUCT:
11086 
          self.ex = TransactionServiceException()
11087 
          self.ex.read(iprot)
11088 
        else:
11089 
          iprot.skip(ftype)
11090 
      else:
11091 
        iprot.skip(ftype)
11092 
      iprot.readFieldEnd()
11093 
    iprot.readStructEnd()
11094 
 
11095 
  def write(self, oprot):
11096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11098 
      return
3064 chandransh 11099 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 11100 
    if self.success is not None:
759 chandransh 11101 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11102 
      oprot.writeBool(self.success)
11103 
      oprot.writeFieldEnd()
3431 rajveer 11104 
    if self.ex is not None:
759 chandransh 11105 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11106 
      self.ex.write(oprot)
11107 
      oprot.writeFieldEnd()
11108 
    oprot.writeFieldStop()
11109 
    oprot.writeStructEnd()
11110 
 
3431 rajveer 11111 
  def validate(self):
11112 
    return
11113 
 
11114 
 
759 chandransh 11115 
  def __repr__(self):
11116 
    L = ['%s=%r' % (key, value)
11117 
      for key, value in self.__dict__.iteritems()]
11118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11119 
 
11120 
  def __eq__(self, other):
11121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11122 
 
11123 
  def __ne__(self, other):
11124 
    return not (self == other)
11125 
 
3064 chandransh 11126 
class acceptOrder_args:
1113 chandransh 11127 
  """
11128 
  Attributes:
3064 chandransh 11129 
   - orderId
1113 chandransh 11130 
  """
11131 
 
11132 
  thrift_spec = (
11133 
    None, # 0
3064 chandransh 11134 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 11135 
  )
11136 
 
3064 chandransh 11137 
  def __init__(self, orderId=None,):
11138 
    self.orderId = orderId
1113 chandransh 11139 
 
11140 
  def read(self, iprot):
11141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11143 
      return
11144 
    iprot.readStructBegin()
11145 
    while True:
11146 
      (fname, ftype, fid) = iprot.readFieldBegin()
11147 
      if ftype == TType.STOP:
11148 
        break
11149 
      if fid == 1:
11150 
        if ftype == TType.I64:
3064 chandransh 11151 
          self.orderId = iprot.readI64();
1113 chandransh 11152 
        else:
11153 
          iprot.skip(ftype)
11154 
      else:
11155 
        iprot.skip(ftype)
11156 
      iprot.readFieldEnd()
11157 
    iprot.readStructEnd()
11158 
 
11159 
  def write(self, oprot):
11160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11162 
      return
3064 chandransh 11163 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 11164 
    if self.orderId is not None:
3064 chandransh 11165 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11166 
      oprot.writeI64(self.orderId)
1113 chandransh 11167 
      oprot.writeFieldEnd()
11168 
    oprot.writeFieldStop()
11169 
    oprot.writeStructEnd()
11170 
 
3431 rajveer 11171 
  def validate(self):
11172 
    return
11173 
 
11174 
 
1113 chandransh 11175 
  def __repr__(self):
11176 
    L = ['%s=%r' % (key, value)
11177 
      for key, value in self.__dict__.iteritems()]
11178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11179 
 
11180 
  def __eq__(self, other):
11181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11182 
 
11183 
  def __ne__(self, other):
11184 
    return not (self == other)
11185 
 
3064 chandransh 11186 
class acceptOrder_result:
1113 chandransh 11187 
  """
11188 
  Attributes:
11189 
   - success
11190 
   - ex
11191 
  """
11192 
 
11193 
  thrift_spec = (
3064 chandransh 11194 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 11195 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11196 
  )
11197 
 
11198 
  def __init__(self, success=None, ex=None,):
11199 
    self.success = success
11200 
    self.ex = ex
11201 
 
11202 
  def read(self, iprot):
11203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11205 
      return
11206 
    iprot.readStructBegin()
11207 
    while True:
11208 
      (fname, ftype, fid) = iprot.readFieldBegin()
11209 
      if ftype == TType.STOP:
11210 
        break
11211 
      if fid == 0:
3064 chandransh 11212 
        if ftype == TType.BOOL:
11213 
          self.success = iprot.readBool();
1113 chandransh 11214 
        else:
11215 
          iprot.skip(ftype)
11216 
      elif fid == 1:
11217 
        if ftype == TType.STRUCT:
11218 
          self.ex = TransactionServiceException()
11219 
          self.ex.read(iprot)
11220 
        else:
11221 
          iprot.skip(ftype)
11222 
      else:
11223 
        iprot.skip(ftype)
11224 
      iprot.readFieldEnd()
11225 
    iprot.readStructEnd()
11226 
 
11227 
  def write(self, oprot):
11228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11230 
      return
3064 chandransh 11231 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 11232 
    if self.success is not None:
3064 chandransh 11233 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11234 
      oprot.writeBool(self.success)
1113 chandransh 11235 
      oprot.writeFieldEnd()
3431 rajveer 11236 
    if self.ex is not None:
1113 chandransh 11237 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11238 
      self.ex.write(oprot)
11239 
      oprot.writeFieldEnd()
11240 
    oprot.writeFieldStop()
11241 
    oprot.writeStructEnd()
11242 
 
3431 rajveer 11243 
  def validate(self):
11244 
    return
11245 
 
11246 
 
1113 chandransh 11247 
  def __repr__(self):
11248 
    L = ['%s=%r' % (key, value)
11249 
      for key, value in self.__dict__.iteritems()]
11250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11251 
 
11252 
  def __eq__(self, other):
11253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11254 
 
11255 
  def __ne__(self, other):
11256 
    return not (self == other)
11257 
 
3064 chandransh 11258 
class addBillingDetails_args:
1135 chandransh 11259 
  """
11260 
  Attributes:
3064 chandransh 11261 
   - orderId
11262 
   - invoice_number
4658 mandeep.dh 11263 
   - serialNumber
4283 anupam.sin 11264 
   - itemNumber
3064 chandransh 11265 
   - billed_by
4264 rajveer 11266 
   - jacketNumber
4283 anupam.sin 11267 
   - billingType
11268 
   - vendorId
4763 rajveer 11269 
   - authorize
1135 chandransh 11270 
  """
11271 
 
11272 
  thrift_spec = (
11273 
    None, # 0
3064 chandransh 11274 
    (1, TType.I64, 'orderId', None, None, ), # 1
11275 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 11276 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 11277 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
11278 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
11279 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
11280 
    (7, TType.I64, 'billingType', None, None, ), # 7
11281 
    (8, TType.I64, 'vendorId', None, None, ), # 8
4763 rajveer 11282 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 11283 
  )
11284 
 
4763 rajveer 11285 
  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 11286 
    self.orderId = orderId
11287 
    self.invoice_number = invoice_number
4658 mandeep.dh 11288 
    self.serialNumber = serialNumber
4283 anupam.sin 11289 
    self.itemNumber = itemNumber
3064 chandransh 11290 
    self.billed_by = billed_by
4264 rajveer 11291 
    self.jacketNumber = jacketNumber
4283 anupam.sin 11292 
    self.billingType = billingType
11293 
    self.vendorId = vendorId
4763 rajveer 11294 
    self.authorize = authorize
1135 chandransh 11295 
 
11296 
  def read(self, iprot):
11297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11299 
      return
11300 
    iprot.readStructBegin()
11301 
    while True:
11302 
      (fname, ftype, fid) = iprot.readFieldBegin()
11303 
      if ftype == TType.STOP:
11304 
        break
11305 
      if fid == 1:
11306 
        if ftype == TType.I64:
3064 chandransh 11307 
          self.orderId = iprot.readI64();
1135 chandransh 11308 
        else:
11309 
          iprot.skip(ftype)
11310 
      elif fid == 2:
3064 chandransh 11311 
        if ftype == TType.STRING:
11312 
          self.invoice_number = iprot.readString();
1135 chandransh 11313 
        else:
11314 
          iprot.skip(ftype)
3064 chandransh 11315 
      elif fid == 3:
4658 mandeep.dh 11316 
        if ftype == TType.STRING:
11317 
          self.serialNumber = iprot.readString();
3064 chandransh 11318 
        else:
11319 
          iprot.skip(ftype)
11320 
      elif fid == 4:
11321 
        if ftype == TType.STRING:
11322 
          self.itemNumber = iprot.readString();
11323 
        else:
11324 
          iprot.skip(ftype)
11325 
      elif fid == 5:
11326 
        if ftype == TType.STRING:
4283 anupam.sin 11327 
          self.billed_by = iprot.readString();
3064 chandransh 11328 
        else:
11329 
          iprot.skip(ftype)
11330 
      elif fid == 6:
11331 
        if ftype == TType.I64:
4283 anupam.sin 11332 
          self.jacketNumber = iprot.readI64();
11333 
        else:
11334 
          iprot.skip(ftype)
11335 
      elif fid == 7:
11336 
        if ftype == TType.I64:
3064 chandransh 11337 
          self.billingType = iprot.readI64();
11338 
        else:
11339 
          iprot.skip(ftype)
4283 anupam.sin 11340 
      elif fid == 8:
11341 
        if ftype == TType.I64:
11342 
          self.vendorId = iprot.readI64();
11343 
        else:
11344 
          iprot.skip(ftype)
4763 rajveer 11345 
      elif fid == 9:
11346 
        if ftype == TType.BOOL:
11347 
          self.authorize = iprot.readBool();
11348 
        else:
11349 
          iprot.skip(ftype)
1246 chandransh 11350 
      else:
11351 
        iprot.skip(ftype)
11352 
      iprot.readFieldEnd()
11353 
    iprot.readStructEnd()
11354 
 
11355 
  def write(self, oprot):
11356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11358 
      return
4283 anupam.sin 11359 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 11360 
    if self.orderId is not None:
3064 chandransh 11361 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11362 
      oprot.writeI64(self.orderId)
1246 chandransh 11363 
      oprot.writeFieldEnd()
4283 anupam.sin 11364 
    if self.invoice_number is not None:
11365 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
11366 
      oprot.writeString(self.invoice_number)
1246 chandransh 11367 
      oprot.writeFieldEnd()
4658 mandeep.dh 11368 
    if self.serialNumber is not None:
11369 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
11370 
      oprot.writeString(self.serialNumber)
3064 chandransh 11371 
      oprot.writeFieldEnd()
3431 rajveer 11372 
    if self.itemNumber is not None:
3064 chandransh 11373 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
11374 
      oprot.writeString(self.itemNumber)
11375 
      oprot.writeFieldEnd()
4283 anupam.sin 11376 
    if self.billed_by is not None:
11377 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
11378 
      oprot.writeString(self.billed_by)
3064 chandransh 11379 
      oprot.writeFieldEnd()
4283 anupam.sin 11380 
    if self.jacketNumber is not None:
11381 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
11382 
      oprot.writeI64(self.jacketNumber)
11383 
      oprot.writeFieldEnd()
3431 rajveer 11384 
    if self.billingType is not None:
4283 anupam.sin 11385 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 11386 
      oprot.writeI64(self.billingType)
11387 
      oprot.writeFieldEnd()
4283 anupam.sin 11388 
    if self.vendorId is not None:
11389 
      oprot.writeFieldBegin('vendorId', TType.I64, 8)
11390 
      oprot.writeI64(self.vendorId)
11391 
      oprot.writeFieldEnd()
4763 rajveer 11392 
    if self.authorize is not None:
11393 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
11394 
      oprot.writeBool(self.authorize)
11395 
      oprot.writeFieldEnd()
1246 chandransh 11396 
    oprot.writeFieldStop()
11397 
    oprot.writeStructEnd()
11398 
 
3431 rajveer 11399 
  def validate(self):
11400 
    return
11401 
 
11402 
 
1246 chandransh 11403 
  def __repr__(self):
11404 
    L = ['%s=%r' % (key, value)
11405 
      for key, value in self.__dict__.iteritems()]
11406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11407 
 
11408 
  def __eq__(self, other):
11409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11410 
 
11411 
  def __ne__(self, other):
11412 
    return not (self == other)
11413 
 
4283 anupam.sin 11414 
class addBillingDetails_result:
1246 chandransh 11415 
  """
11416 
  Attributes:
3064 chandransh 11417 
   - success
1246 chandransh 11418 
   - ex
11419 
  """
11420 
 
11421 
  thrift_spec = (
3064 chandransh 11422 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 11423 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11424 
  )
11425 
 
3064 chandransh 11426 
  def __init__(self, success=None, ex=None,):
11427 
    self.success = success
1246 chandransh 11428 
    self.ex = ex
11429 
 
11430 
  def read(self, iprot):
11431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11433 
      return
11434 
    iprot.readStructBegin()
11435 
    while True:
11436 
      (fname, ftype, fid) = iprot.readFieldBegin()
11437 
      if ftype == TType.STOP:
11438 
        break
3064 chandransh 11439 
      if fid == 0:
11440 
        if ftype == TType.BOOL:
11441 
          self.success = iprot.readBool();
11442 
        else:
11443 
          iprot.skip(ftype)
11444 
      elif fid == 1:
1246 chandransh 11445 
        if ftype == TType.STRUCT:
11446 
          self.ex = TransactionServiceException()
11447 
          self.ex.read(iprot)
11448 
        else:
11449 
          iprot.skip(ftype)
11450 
      else:
11451 
        iprot.skip(ftype)
11452 
      iprot.readFieldEnd()
11453 
    iprot.readStructEnd()
11454 
 
11455 
  def write(self, oprot):
11456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11458 
      return
4283 anupam.sin 11459 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 11460 
    if self.success is not None:
3064 chandransh 11461 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11462 
      oprot.writeBool(self.success)
11463 
      oprot.writeFieldEnd()
3431 rajveer 11464 
    if self.ex is not None:
1246 chandransh 11465 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11466 
      self.ex.write(oprot)
11467 
      oprot.writeFieldEnd()
11468 
    oprot.writeFieldStop()
11469 
    oprot.writeStructEnd()
11470 
 
3431 rajveer 11471 
  def validate(self):
11472 
    return
11473 
 
11474 
 
1246 chandransh 11475 
  def __repr__(self):
11476 
    L = ['%s=%r' % (key, value)
11477 
      for key, value in self.__dict__.iteritems()]
11478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11479 
 
11480 
  def __eq__(self, other):
11481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11482 
 
11483 
  def __ne__(self, other):
11484 
    return not (self == other)
11485 
 
4579 rajveer 11486 
class addInvoiceNumber_args:
11487 
  """
11488 
  Attributes:
11489 
   - orderId
11490 
   - invoiceNumber
4763 rajveer 11491 
   - color
4579 rajveer 11492 
  """
11493 
 
11494 
  thrift_spec = (
11495 
    None, # 0
11496 
    (1, TType.I64, 'orderId', None, None, ), # 1
11497 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 11498 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 11499 
  )
11500 
 
4763 rajveer 11501 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 11502 
    self.orderId = orderId
11503 
    self.invoiceNumber = invoiceNumber
4763 rajveer 11504 
    self.color = color
4579 rajveer 11505 
 
11506 
  def read(self, iprot):
11507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11509 
      return
11510 
    iprot.readStructBegin()
11511 
    while True:
11512 
      (fname, ftype, fid) = iprot.readFieldBegin()
11513 
      if ftype == TType.STOP:
11514 
        break
11515 
      if fid == 1:
11516 
        if ftype == TType.I64:
11517 
          self.orderId = iprot.readI64();
11518 
        else:
11519 
          iprot.skip(ftype)
11520 
      elif fid == 2:
11521 
        if ftype == TType.STRING:
11522 
          self.invoiceNumber = iprot.readString();
11523 
        else:
11524 
          iprot.skip(ftype)
4763 rajveer 11525 
      elif fid == 3:
11526 
        if ftype == TType.STRING:
11527 
          self.color = iprot.readString();
11528 
        else:
11529 
          iprot.skip(ftype)
4579 rajveer 11530 
      else:
11531 
        iprot.skip(ftype)
11532 
      iprot.readFieldEnd()
11533 
    iprot.readStructEnd()
11534 
 
11535 
  def write(self, oprot):
11536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11538 
      return
11539 
    oprot.writeStructBegin('addInvoiceNumber_args')
11540 
    if self.orderId is not None:
11541 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11542 
      oprot.writeI64(self.orderId)
11543 
      oprot.writeFieldEnd()
11544 
    if self.invoiceNumber is not None:
11545 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
11546 
      oprot.writeString(self.invoiceNumber)
11547 
      oprot.writeFieldEnd()
4763 rajveer 11548 
    if self.color is not None:
11549 
      oprot.writeFieldBegin('color', TType.STRING, 3)
11550 
      oprot.writeString(self.color)
11551 
      oprot.writeFieldEnd()
4579 rajveer 11552 
    oprot.writeFieldStop()
11553 
    oprot.writeStructEnd()
11554 
 
11555 
  def validate(self):
11556 
    return
11557 
 
11558 
 
11559 
  def __repr__(self):
11560 
    L = ['%s=%r' % (key, value)
11561 
      for key, value in self.__dict__.iteritems()]
11562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11563 
 
11564 
  def __eq__(self, other):
11565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11566 
 
11567 
  def __ne__(self, other):
11568 
    return not (self == other)
11569 
 
11570 
class addInvoiceNumber_result:
11571 
  """
11572 
  Attributes:
11573 
   - ex
11574 
  """
11575 
 
11576 
  thrift_spec = (
11577 
    None, # 0
11578 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11579 
  )
11580 
 
11581 
  def __init__(self, ex=None,):
11582 
    self.ex = ex
11583 
 
11584 
  def read(self, iprot):
11585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11587 
      return
11588 
    iprot.readStructBegin()
11589 
    while True:
11590 
      (fname, ftype, fid) = iprot.readFieldBegin()
11591 
      if ftype == TType.STOP:
11592 
        break
11593 
      if fid == 1:
11594 
        if ftype == TType.STRUCT:
11595 
          self.ex = TransactionServiceException()
11596 
          self.ex.read(iprot)
11597 
        else:
11598 
          iprot.skip(ftype)
11599 
      else:
11600 
        iprot.skip(ftype)
11601 
      iprot.readFieldEnd()
11602 
    iprot.readStructEnd()
11603 
 
11604 
  def write(self, oprot):
11605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11607 
      return
11608 
    oprot.writeStructBegin('addInvoiceNumber_result')
11609 
    if self.ex is not None:
11610 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11611 
      self.ex.write(oprot)
11612 
      oprot.writeFieldEnd()
11613 
    oprot.writeFieldStop()
11614 
    oprot.writeStructEnd()
11615 
 
11616 
  def validate(self):
11617 
    return
11618 
 
11619 
 
11620 
  def __repr__(self):
11621 
    L = ['%s=%r' % (key, value)
11622 
      for key, value in self.__dict__.iteritems()]
11623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11624 
 
11625 
  def __eq__(self, other):
11626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11627 
 
11628 
  def __ne__(self, other):
11629 
    return not (self == other)
11630 
 
4910 phani.kuma 11631 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 11632 
  """
11633 
  Attributes:
3064 chandransh 11634 
   - warehouseId
1408 ankur.sing 11635 
   - providerId
3064 chandransh 11636 
   - cod
4910 phani.kuma 11637 
   - orderIds
1408 ankur.sing 11638 
  """
11639 
 
11640 
  thrift_spec = (
11641 
    None, # 0
3064 chandransh 11642 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11643 
    (2, TType.I64, 'providerId', None, None, ), # 2
11644 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 11645 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 11646 
  )
11647 
 
4910 phani.kuma 11648 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 11649 
    self.warehouseId = warehouseId
1408 ankur.sing 11650 
    self.providerId = providerId
3064 chandransh 11651 
    self.cod = cod
4910 phani.kuma 11652 
    self.orderIds = orderIds
1408 ankur.sing 11653 
 
11654 
  def read(self, iprot):
11655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11657 
      return
11658 
    iprot.readStructBegin()
11659 
    while True:
11660 
      (fname, ftype, fid) = iprot.readFieldBegin()
11661 
      if ftype == TType.STOP:
11662 
        break
11663 
      if fid == 1:
11664 
        if ftype == TType.I64:
3064 chandransh 11665 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 11666 
        else:
11667 
          iprot.skip(ftype)
11668 
      elif fid == 2:
11669 
        if ftype == TType.I64:
3064 chandransh 11670 
          self.providerId = iprot.readI64();
1408 ankur.sing 11671 
        else:
11672 
          iprot.skip(ftype)
3064 chandransh 11673 
      elif fid == 3:
11674 
        if ftype == TType.BOOL:
11675 
          self.cod = iprot.readBool();
11676 
        else:
11677 
          iprot.skip(ftype)
4910 phani.kuma 11678 
      elif fid == 4:
11679 
        if ftype == TType.LIST:
11680 
          self.orderIds = []
5031 varun.gupt 11681 
          (_etype213, _size210) = iprot.readListBegin()
11682 
          for _i214 in xrange(_size210):
11683 
            _elem215 = iprot.readI64();
11684 
            self.orderIds.append(_elem215)
4910 phani.kuma 11685 
          iprot.readListEnd()
11686 
        else:
11687 
          iprot.skip(ftype)
1408 ankur.sing 11688 
      else:
11689 
        iprot.skip(ftype)
11690 
      iprot.readFieldEnd()
11691 
    iprot.readStructEnd()
11692 
 
11693 
  def write(self, oprot):
11694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11696 
      return
4910 phani.kuma 11697 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 11698 
    if self.warehouseId is not None:
3064 chandransh 11699 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11700 
      oprot.writeI64(self.warehouseId)
11701 
      oprot.writeFieldEnd()
3431 rajveer 11702 
    if self.providerId is not None:
3064 chandransh 11703 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 11704 
      oprot.writeI64(self.providerId)
11705 
      oprot.writeFieldEnd()
3431 rajveer 11706 
    if self.cod is not None:
3064 chandransh 11707 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
11708 
      oprot.writeBool(self.cod)
1408 ankur.sing 11709 
      oprot.writeFieldEnd()
4910 phani.kuma 11710 
    if self.orderIds is not None:
11711 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
11712 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5031 varun.gupt 11713 
      for iter216 in self.orderIds:
11714 
        oprot.writeI64(iter216)
4910 phani.kuma 11715 
      oprot.writeListEnd()
11716 
      oprot.writeFieldEnd()
1408 ankur.sing 11717 
    oprot.writeFieldStop()
11718 
    oprot.writeStructEnd()
11719 
 
3431 rajveer 11720 
  def validate(self):
11721 
    return
11722 
 
11723 
 
1408 ankur.sing 11724 
  def __repr__(self):
11725 
    L = ['%s=%r' % (key, value)
11726 
      for key, value in self.__dict__.iteritems()]
11727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11728 
 
11729 
  def __eq__(self, other):
11730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11731 
 
11732 
  def __ne__(self, other):
11733 
    return not (self == other)
11734 
 
4910 phani.kuma 11735 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 11736 
  """
11737 
  Attributes:
11738 
   - success
3064 chandransh 11739 
   - ex
1408 ankur.sing 11740 
  """
11741 
 
11742 
  thrift_spec = (
3064 chandransh 11743 
    (0, TType.BOOL, 'success', None, None, ), # 0
11744 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 11745 
  )
11746 
 
3064 chandransh 11747 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 11748 
    self.success = success
3064 chandransh 11749 
    self.ex = ex
1408 ankur.sing 11750 
 
11751 
  def read(self, iprot):
11752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11754 
      return
11755 
    iprot.readStructBegin()
11756 
    while True:
11757 
      (fname, ftype, fid) = iprot.readFieldBegin()
11758 
      if ftype == TType.STOP:
11759 
        break
11760 
      if fid == 0:
3064 chandransh 11761 
        if ftype == TType.BOOL:
11762 
          self.success = iprot.readBool();
1408 ankur.sing 11763 
        else:
11764 
          iprot.skip(ftype)
3064 chandransh 11765 
      elif fid == 1:
11766 
        if ftype == TType.STRUCT:
11767 
          self.ex = TransactionServiceException()
11768 
          self.ex.read(iprot)
11769 
        else:
11770 
          iprot.skip(ftype)
1408 ankur.sing 11771 
      else:
11772 
        iprot.skip(ftype)
11773 
      iprot.readFieldEnd()
11774 
    iprot.readStructEnd()
11775 
 
11776 
  def write(self, oprot):
11777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11779 
      return
4910 phani.kuma 11780 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 11781 
    if self.success is not None:
3064 chandransh 11782 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11783 
      oprot.writeBool(self.success)
1408 ankur.sing 11784 
      oprot.writeFieldEnd()
3431 rajveer 11785 
    if self.ex is not None:
3064 chandransh 11786 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11787 
      self.ex.write(oprot)
11788 
      oprot.writeFieldEnd()
1408 ankur.sing 11789 
    oprot.writeFieldStop()
11790 
    oprot.writeStructEnd()
11791 
 
3431 rajveer 11792 
  def validate(self):
11793 
    return
11794 
 
11795 
 
1408 ankur.sing 11796 
  def __repr__(self):
11797 
    L = ['%s=%r' % (key, value)
11798 
      for key, value in self.__dict__.iteritems()]
11799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11800 
 
11801 
  def __eq__(self, other):
11802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11803 
 
11804 
  def __ne__(self, other):
11805 
    return not (self == other)
11806 
 
4910 phani.kuma 11807 
class markOrdersAsPickedUp_args:
4410 rajveer 11808 
  """
11809 
  Attributes:
11810 
   - providerId
4910 phani.kuma 11811 
   - pickupDetails
4410 rajveer 11812 
  """
11813 
 
11814 
  thrift_spec = (
11815 
    None, # 0
4910 phani.kuma 11816 
    (1, TType.I64, 'providerId', None, None, ), # 1
11817 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 11818 
  )
11819 
 
4910 phani.kuma 11820 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 11821 
    self.providerId = providerId
4910 phani.kuma 11822 
    self.pickupDetails = pickupDetails
4410 rajveer 11823 
 
11824 
  def read(self, iprot):
11825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11827 
      return
11828 
    iprot.readStructBegin()
11829 
    while True:
11830 
      (fname, ftype, fid) = iprot.readFieldBegin()
11831 
      if ftype == TType.STOP:
11832 
        break
11833 
      if fid == 1:
11834 
        if ftype == TType.I64:
4910 phani.kuma 11835 
          self.providerId = iprot.readI64();
4410 rajveer 11836 
        else:
11837 
          iprot.skip(ftype)
11838 
      elif fid == 2:
4910 phani.kuma 11839 
        if ftype == TType.MAP:
11840 
          self.pickupDetails = {}
5031 varun.gupt 11841 
          (_ktype218, _vtype219, _size217 ) = iprot.readMapBegin()
11842 
          for _i221 in xrange(_size217):
11843 
            _key222 = iprot.readString();
11844 
            _val223 = iprot.readString();
11845 
            self.pickupDetails[_key222] = _val223
4910 phani.kuma 11846 
          iprot.readMapEnd()
4410 rajveer 11847 
        else:
11848 
          iprot.skip(ftype)
11849 
      else:
11850 
        iprot.skip(ftype)
11851 
      iprot.readFieldEnd()
11852 
    iprot.readStructEnd()
11853 
 
11854 
  def write(self, oprot):
11855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11857 
      return
4910 phani.kuma 11858 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 11859 
    if self.providerId is not None:
4910 phani.kuma 11860 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 11861 
      oprot.writeI64(self.providerId)
11862 
      oprot.writeFieldEnd()
4910 phani.kuma 11863 
    if self.pickupDetails is not None:
11864 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11865 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 11866 
      for kiter224,viter225 in self.pickupDetails.items():
11867 
        oprot.writeString(kiter224)
11868 
        oprot.writeString(viter225)
4910 phani.kuma 11869 
      oprot.writeMapEnd()
4410 rajveer 11870 
      oprot.writeFieldEnd()
11871 
    oprot.writeFieldStop()
11872 
    oprot.writeStructEnd()
11873 
 
11874 
  def validate(self):
11875 
    return
11876 
 
11877 
 
11878 
  def __repr__(self):
11879 
    L = ['%s=%r' % (key, value)
11880 
      for key, value in self.__dict__.iteritems()]
11881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11882 
 
11883 
  def __eq__(self, other):
11884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11885 
 
11886 
  def __ne__(self, other):
11887 
    return not (self == other)
11888 
 
4910 phani.kuma 11889 
class markOrdersAsPickedUp_result:
4410 rajveer 11890 
  """
11891 
  Attributes:
11892 
   - ex
11893 
  """
11894 
 
11895 
  thrift_spec = (
4910 phani.kuma 11896 
    None, # 0
4410 rajveer 11897 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11898 
  )
11899 
 
4910 phani.kuma 11900 
  def __init__(self, ex=None,):
4410 rajveer 11901 
    self.ex = ex
11902 
 
11903 
  def read(self, iprot):
11904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11906 
      return
11907 
    iprot.readStructBegin()
11908 
    while True:
11909 
      (fname, ftype, fid) = iprot.readFieldBegin()
11910 
      if ftype == TType.STOP:
11911 
        break
4910 phani.kuma 11912 
      if fid == 1:
4410 rajveer 11913 
        if ftype == TType.STRUCT:
11914 
          self.ex = TransactionServiceException()
11915 
          self.ex.read(iprot)
11916 
        else:
11917 
          iprot.skip(ftype)
11918 
      else:
11919 
        iprot.skip(ftype)
11920 
      iprot.readFieldEnd()
11921 
    iprot.readStructEnd()
11922 
 
11923 
  def write(self, oprot):
11924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11926 
      return
4910 phani.kuma 11927 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 11928 
    if self.ex is not None:
11929 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11930 
      self.ex.write(oprot)
11931 
      oprot.writeFieldEnd()
11932 
    oprot.writeFieldStop()
11933 
    oprot.writeStructEnd()
11934 
 
11935 
  def validate(self):
11936 
    return
11937 
 
11938 
 
11939 
  def __repr__(self):
11940 
    L = ['%s=%r' % (key, value)
11941 
      for key, value in self.__dict__.iteritems()]
11942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11943 
 
11944 
  def __eq__(self, other):
11945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11946 
 
11947 
  def __ne__(self, other):
11948 
    return not (self == other)
11949 
 
4910 phani.kuma 11950 
class getOrdersNotPickedUp_args:
304 ashish 11951 
  """
11952 
  Attributes:
3064 chandransh 11953 
   - providerId
304 ashish 11954 
  """
94 ashish 11955 
 
304 ashish 11956 
  thrift_spec = (
11957 
    None, # 0
3064 chandransh 11958 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 11959 
  )
11960 
 
4910 phani.kuma 11961 
  def __init__(self, providerId=None,):
3064 chandransh 11962 
    self.providerId = providerId
304 ashish 11963 
 
11964 
  def read(self, iprot):
11965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11967 
      return
11968 
    iprot.readStructBegin()
11969 
    while True:
11970 
      (fname, ftype, fid) = iprot.readFieldBegin()
11971 
      if ftype == TType.STOP:
11972 
        break
11973 
      if fid == 1:
11974 
        if ftype == TType.I64:
3064 chandransh 11975 
          self.providerId = iprot.readI64();
304 ashish 11976 
        else:
11977 
          iprot.skip(ftype)
11978 
      else:
11979 
        iprot.skip(ftype)
11980 
      iprot.readFieldEnd()
11981 
    iprot.readStructEnd()
11982 
 
11983 
  def write(self, oprot):
11984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11986 
      return
4910 phani.kuma 11987 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 11988 
    if self.providerId is not None:
3064 chandransh 11989 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
11990 
      oprot.writeI64(self.providerId)
304 ashish 11991 
      oprot.writeFieldEnd()
11992 
    oprot.writeFieldStop()
11993 
    oprot.writeStructEnd()
11994 
 
3431 rajveer 11995 
  def validate(self):
11996 
    return
11997 
 
11998 
 
304 ashish 11999 
  def __repr__(self):
12000 
    L = ['%s=%r' % (key, value)
12001 
      for key, value in self.__dict__.iteritems()]
12002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12003 
 
12004 
  def __eq__(self, other):
12005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12006 
 
12007 
  def __ne__(self, other):
12008 
    return not (self == other)
12009 
 
4910 phani.kuma 12010 
class getOrdersNotPickedUp_result:
304 ashish 12011 
  """
12012 
  Attributes:
12013 
   - success
12014 
  """
12015 
 
12016 
  thrift_spec = (
3064 chandransh 12017 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 12018 
  )
12019 
 
4910 phani.kuma 12020 
  def __init__(self, success=None,):
304 ashish 12021 
    self.success = success
12022 
 
12023 
  def read(self, iprot):
12024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12026 
      return
12027 
    iprot.readStructBegin()
12028 
    while True:
12029 
      (fname, ftype, fid) = iprot.readFieldBegin()
12030 
      if ftype == TType.STOP:
12031 
        break
12032 
      if fid == 0:
12033 
        if ftype == TType.LIST:
12034 
          self.success = []
5031 varun.gupt 12035 
          (_etype229, _size226) = iprot.readListBegin()
12036 
          for _i230 in xrange(_size226):
12037 
            _elem231 = Order()
12038 
            _elem231.read(iprot)
12039 
            self.success.append(_elem231)
304 ashish 12040 
          iprot.readListEnd()
12041 
        else:
12042 
          iprot.skip(ftype)
12043 
      else:
12044 
        iprot.skip(ftype)
12045 
      iprot.readFieldEnd()
12046 
    iprot.readStructEnd()
12047 
 
12048 
  def write(self, oprot):
12049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12051 
      return
4910 phani.kuma 12052 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 12053 
    if self.success is not None:
304 ashish 12054 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12055 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12056 
      for iter232 in self.success:
12057 
        iter232.write(oprot)
304 ashish 12058 
      oprot.writeListEnd()
12059 
      oprot.writeFieldEnd()
12060 
    oprot.writeFieldStop()
12061 
    oprot.writeStructEnd()
12062 
 
3431 rajveer 12063 
  def validate(self):
12064 
    return
12065 
 
12066 
 
304 ashish 12067 
  def __repr__(self):
12068 
    L = ['%s=%r' % (key, value)
12069 
      for key, value in self.__dict__.iteritems()]
12070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12071 
 
12072 
  def __eq__(self, other):
12073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12074 
 
12075 
  def __ne__(self, other):
12076 
    return not (self == other)
12077 
 
3064 chandransh 12078 
class markOrdersAsDelivered_args:
304 ashish 12079 
  """
12080 
  Attributes:
3064 chandransh 12081 
   - providerId
12082 
   - deliveredOrders
304 ashish 12083 
  """
12084 
 
12085 
  thrift_spec = (
12086 
    None, # 0
3064 chandransh 12087 
    (1, TType.I64, 'providerId', None, None, ), # 1
12088 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 12089 
  )
12090 
 
3064 chandransh 12091 
  def __init__(self, providerId=None, deliveredOrders=None,):
12092 
    self.providerId = providerId
12093 
    self.deliveredOrders = deliveredOrders
304 ashish 12094 
 
12095 
  def read(self, iprot):
12096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12098 
      return
12099 
    iprot.readStructBegin()
12100 
    while True:
12101 
      (fname, ftype, fid) = iprot.readFieldBegin()
12102 
      if ftype == TType.STOP:
12103 
        break
12104 
      if fid == 1:
12105 
        if ftype == TType.I64:
3064 chandransh 12106 
          self.providerId = iprot.readI64();
304 ashish 12107 
        else:
12108 
          iprot.skip(ftype)
12109 
      elif fid == 2:
3064 chandransh 12110 
        if ftype == TType.MAP:
12111 
          self.deliveredOrders = {}
5031 varun.gupt 12112 
          (_ktype234, _vtype235, _size233 ) = iprot.readMapBegin()
12113 
          for _i237 in xrange(_size233):
12114 
            _key238 = iprot.readString();
12115 
            _val239 = iprot.readString();
12116 
            self.deliveredOrders[_key238] = _val239
3064 chandransh 12117 
          iprot.readMapEnd()
304 ashish 12118 
        else:
12119 
          iprot.skip(ftype)
12120 
      else:
12121 
        iprot.skip(ftype)
12122 
      iprot.readFieldEnd()
12123 
    iprot.readStructEnd()
12124 
 
12125 
  def write(self, oprot):
12126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12128 
      return
3064 chandransh 12129 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 12130 
    if self.providerId is not None:
3064 chandransh 12131 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12132 
      oprot.writeI64(self.providerId)
304 ashish 12133 
      oprot.writeFieldEnd()
3431 rajveer 12134 
    if self.deliveredOrders is not None:
3064 chandransh 12135 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
12136 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
5031 varun.gupt 12137 
      for kiter240,viter241 in self.deliveredOrders.items():
12138 
        oprot.writeString(kiter240)
12139 
        oprot.writeString(viter241)
3064 chandransh 12140 
      oprot.writeMapEnd()
304 ashish 12141 
      oprot.writeFieldEnd()
12142 
    oprot.writeFieldStop()
12143 
    oprot.writeStructEnd()
12144 
 
3431 rajveer 12145 
  def validate(self):
12146 
    return
12147 
 
12148 
 
304 ashish 12149 
  def __repr__(self):
12150 
    L = ['%s=%r' % (key, value)
12151 
      for key, value in self.__dict__.iteritems()]
12152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12153 
 
12154 
  def __eq__(self, other):
12155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12156 
 
12157 
  def __ne__(self, other):
12158 
    return not (self == other)
12159 
 
3064 chandransh 12160 
class markOrdersAsDelivered_result:
12161 
  """
12162 
  Attributes:
12163 
   - ex
12164 
  """
304 ashish 12165 
 
12166 
  thrift_spec = (
3064 chandransh 12167 
    None, # 0
12168 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 12169 
  )
12170 
 
3064 chandransh 12171 
  def __init__(self, ex=None,):
12172 
    self.ex = ex
304 ashish 12173 
 
1596 ankur.sing 12174 
  def read(self, iprot):
12175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12177 
      return
12178 
    iprot.readStructBegin()
12179 
    while True:
12180 
      (fname, ftype, fid) = iprot.readFieldBegin()
12181 
      if ftype == TType.STOP:
12182 
        break
3064 chandransh 12183 
      if fid == 1:
12184 
        if ftype == TType.STRUCT:
12185 
          self.ex = TransactionServiceException()
12186 
          self.ex.read(iprot)
12187 
        else:
12188 
          iprot.skip(ftype)
1596 ankur.sing 12189 
      else:
12190 
        iprot.skip(ftype)
12191 
      iprot.readFieldEnd()
12192 
    iprot.readStructEnd()
12193 
 
12194 
  def write(self, oprot):
12195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12197 
      return
3064 chandransh 12198 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 12199 
    if self.ex is not None:
3064 chandransh 12200 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12201 
      self.ex.write(oprot)
12202 
      oprot.writeFieldEnd()
1596 ankur.sing 12203 
    oprot.writeFieldStop()
12204 
    oprot.writeStructEnd()
12205 
 
3431 rajveer 12206 
  def validate(self):
12207 
    return
12208 
 
12209 
 
1596 ankur.sing 12210 
  def __repr__(self):
12211 
    L = ['%s=%r' % (key, value)
12212 
      for key, value in self.__dict__.iteritems()]
12213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12214 
 
12215 
  def __eq__(self, other):
12216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12217 
 
12218 
  def __ne__(self, other):
12219 
    return not (self == other)
12220 
 
4910 phani.kuma 12221 
class markAsRTOrders_args:
1596 ankur.sing 12222 
  """
12223 
  Attributes:
3064 chandransh 12224 
   - providerId
12225 
   - returnedOrders
1596 ankur.sing 12226 
  """
12227 
 
12228 
  thrift_spec = (
3064 chandransh 12229 
    None, # 0
12230 
    (1, TType.I64, 'providerId', None, None, ), # 1
12231 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 12232 
  )
12233 
 
3064 chandransh 12234 
  def __init__(self, providerId=None, returnedOrders=None,):
12235 
    self.providerId = providerId
12236 
    self.returnedOrders = returnedOrders
1596 ankur.sing 12237 
 
12238 
  def read(self, iprot):
12239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12241 
      return
12242 
    iprot.readStructBegin()
12243 
    while True:
12244 
      (fname, ftype, fid) = iprot.readFieldBegin()
12245 
      if ftype == TType.STOP:
12246 
        break
3064 chandransh 12247 
      if fid == 1:
1596 ankur.sing 12248 
        if ftype == TType.I64:
3064 chandransh 12249 
          self.providerId = iprot.readI64();
1596 ankur.sing 12250 
        else:
12251 
          iprot.skip(ftype)
3064 chandransh 12252 
      elif fid == 2:
12253 
        if ftype == TType.MAP:
12254 
          self.returnedOrders = {}
5031 varun.gupt 12255 
          (_ktype243, _vtype244, _size242 ) = iprot.readMapBegin()
12256 
          for _i246 in xrange(_size242):
12257 
            _key247 = iprot.readString();
12258 
            _val248 = iprot.readString();
12259 
            self.returnedOrders[_key247] = _val248
3064 chandransh 12260 
          iprot.readMapEnd()
12261 
        else:
12262 
          iprot.skip(ftype)
1596 ankur.sing 12263 
      else:
12264 
        iprot.skip(ftype)
12265 
      iprot.readFieldEnd()
12266 
    iprot.readStructEnd()
12267 
 
12268 
  def write(self, oprot):
12269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12271 
      return
4910 phani.kuma 12272 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 12273 
    if self.providerId is not None:
3064 chandransh 12274 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12275 
      oprot.writeI64(self.providerId)
1596 ankur.sing 12276 
      oprot.writeFieldEnd()
3431 rajveer 12277 
    if self.returnedOrders is not None:
3064 chandransh 12278 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
12279 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
5031 varun.gupt 12280 
      for kiter249,viter250 in self.returnedOrders.items():
12281 
        oprot.writeString(kiter249)
12282 
        oprot.writeString(viter250)
3064 chandransh 12283 
      oprot.writeMapEnd()
12284 
      oprot.writeFieldEnd()
1596 ankur.sing 12285 
    oprot.writeFieldStop()
12286 
    oprot.writeStructEnd()
12287 
 
3431 rajveer 12288 
  def validate(self):
12289 
    return
12290 
 
12291 
 
1596 ankur.sing 12292 
  def __repr__(self):
12293 
    L = ['%s=%r' % (key, value)
12294 
      for key, value in self.__dict__.iteritems()]
12295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12296 
 
12297 
  def __eq__(self, other):
12298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12299 
 
12300 
  def __ne__(self, other):
12301 
    return not (self == other)
12302 
 
4910 phani.kuma 12303 
class markAsRTOrders_result:
3064 chandransh 12304 
  """
12305 
  Attributes:
12306 
   - ex
12307 
  """
1596 ankur.sing 12308 
 
1627 ankur.sing 12309 
  thrift_spec = (
3064 chandransh 12310 
    None, # 0
12311 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12312 
  )
12313 
 
3064 chandransh 12314 
  def __init__(self, ex=None,):
12315 
    self.ex = ex
12316 
 
1627 ankur.sing 12317 
  def read(self, iprot):
12318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12320 
      return
12321 
    iprot.readStructBegin()
12322 
    while True:
12323 
      (fname, ftype, fid) = iprot.readFieldBegin()
12324 
      if ftype == TType.STOP:
12325 
        break
3064 chandransh 12326 
      if fid == 1:
12327 
        if ftype == TType.STRUCT:
12328 
          self.ex = TransactionServiceException()
12329 
          self.ex.read(iprot)
12330 
        else:
12331 
          iprot.skip(ftype)
1627 ankur.sing 12332 
      else:
12333 
        iprot.skip(ftype)
12334 
      iprot.readFieldEnd()
12335 
    iprot.readStructEnd()
12336 
 
12337 
  def write(self, oprot):
12338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12340 
      return
4910 phani.kuma 12341 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 12342 
    if self.ex is not None:
3064 chandransh 12343 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12344 
      self.ex.write(oprot)
12345 
      oprot.writeFieldEnd()
1627 ankur.sing 12346 
    oprot.writeFieldStop()
12347 
    oprot.writeStructEnd()
12348 
 
3431 rajveer 12349 
  def validate(self):
12350 
    return
12351 
 
12352 
 
1627 ankur.sing 12353 
  def __repr__(self):
12354 
    L = ['%s=%r' % (key, value)
12355 
      for key, value in self.__dict__.iteritems()]
12356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12357 
 
12358 
  def __eq__(self, other):
12359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12360 
 
12361 
  def __ne__(self, other):
12362 
    return not (self == other)
12363 
 
4910 phani.kuma 12364 
class getRTOrders_args:
12365 
  """
12366 
  Attributes:
12367 
   - providerId
12368 
  """
12369 
 
12370 
  thrift_spec = (
12371 
    None, # 0
12372 
    (1, TType.I64, 'providerId', None, None, ), # 1
12373 
  )
12374 
 
12375 
  def __init__(self, providerId=None,):
12376 
    self.providerId = providerId
12377 
 
12378 
  def read(self, iprot):
12379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12381 
      return
12382 
    iprot.readStructBegin()
12383 
    while True:
12384 
      (fname, ftype, fid) = iprot.readFieldBegin()
12385 
      if ftype == TType.STOP:
12386 
        break
12387 
      if fid == 1:
12388 
        if ftype == TType.I64:
12389 
          self.providerId = iprot.readI64();
12390 
        else:
12391 
          iprot.skip(ftype)
12392 
      else:
12393 
        iprot.skip(ftype)
12394 
      iprot.readFieldEnd()
12395 
    iprot.readStructEnd()
12396 
 
12397 
  def write(self, oprot):
12398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12400 
      return
12401 
    oprot.writeStructBegin('getRTOrders_args')
12402 
    if self.providerId is not None:
12403 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12404 
      oprot.writeI64(self.providerId)
12405 
      oprot.writeFieldEnd()
12406 
    oprot.writeFieldStop()
12407 
    oprot.writeStructEnd()
12408 
 
12409 
  def validate(self):
12410 
    return
12411 
 
12412 
 
12413 
  def __repr__(self):
12414 
    L = ['%s=%r' % (key, value)
12415 
      for key, value in self.__dict__.iteritems()]
12416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12417 
 
12418 
  def __eq__(self, other):
12419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12420 
 
12421 
  def __ne__(self, other):
12422 
    return not (self == other)
12423 
 
12424 
class getRTOrders_result:
12425 
  """
12426 
  Attributes:
12427 
   - success
12428 
  """
12429 
 
12430 
  thrift_spec = (
12431 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12432 
  )
12433 
 
12434 
  def __init__(self, success=None,):
12435 
    self.success = success
12436 
 
12437 
  def read(self, iprot):
12438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12440 
      return
12441 
    iprot.readStructBegin()
12442 
    while True:
12443 
      (fname, ftype, fid) = iprot.readFieldBegin()
12444 
      if ftype == TType.STOP:
12445 
        break
12446 
      if fid == 0:
12447 
        if ftype == TType.LIST:
12448 
          self.success = []
5031 varun.gupt 12449 
          (_etype254, _size251) = iprot.readListBegin()
12450 
          for _i255 in xrange(_size251):
12451 
            _elem256 = Order()
12452 
            _elem256.read(iprot)
12453 
            self.success.append(_elem256)
4910 phani.kuma 12454 
          iprot.readListEnd()
12455 
        else:
12456 
          iprot.skip(ftype)
12457 
      else:
12458 
        iprot.skip(ftype)
12459 
      iprot.readFieldEnd()
12460 
    iprot.readStructEnd()
12461 
 
12462 
  def write(self, oprot):
12463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12465 
      return
12466 
    oprot.writeStructBegin('getRTOrders_result')
12467 
    if self.success is not None:
12468 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12469 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12470 
      for iter257 in self.success:
12471 
        iter257.write(oprot)
4910 phani.kuma 12472 
      oprot.writeListEnd()
12473 
      oprot.writeFieldEnd()
12474 
    oprot.writeFieldStop()
12475 
    oprot.writeStructEnd()
12476 
 
12477 
  def validate(self):
12478 
    return
12479 
 
12480 
 
12481 
  def __repr__(self):
12482 
    L = ['%s=%r' % (key, value)
12483 
      for key, value in self.__dict__.iteritems()]
12484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12485 
 
12486 
  def __eq__(self, other):
12487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12488 
 
12489 
  def __ne__(self, other):
12490 
    return not (self == other)
12491 
 
3064 chandransh 12492 
class updateNonDeliveryReason_args:
1627 ankur.sing 12493 
  """
12494 
  Attributes:
3064 chandransh 12495 
   - providerId
12496 
   - undeliveredOrders
1627 ankur.sing 12497 
  """
12498 
 
12499 
  thrift_spec = (
3064 chandransh 12500 
    None, # 0
12501 
    (1, TType.I64, 'providerId', None, None, ), # 1
12502 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 12503 
  )
12504 
 
3064 chandransh 12505 
  def __init__(self, providerId=None, undeliveredOrders=None,):
12506 
    self.providerId = providerId
12507 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 12508 
 
12509 
  def read(self, iprot):
12510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12512 
      return
12513 
    iprot.readStructBegin()
12514 
    while True:
12515 
      (fname, ftype, fid) = iprot.readFieldBegin()
12516 
      if ftype == TType.STOP:
12517 
        break
3064 chandransh 12518 
      if fid == 1:
1627 ankur.sing 12519 
        if ftype == TType.I64:
3064 chandransh 12520 
          self.providerId = iprot.readI64();
1627 ankur.sing 12521 
        else:
12522 
          iprot.skip(ftype)
3064 chandransh 12523 
      elif fid == 2:
12524 
        if ftype == TType.MAP:
12525 
          self.undeliveredOrders = {}
5031 varun.gupt 12526 
          (_ktype259, _vtype260, _size258 ) = iprot.readMapBegin()
12527 
          for _i262 in xrange(_size258):
12528 
            _key263 = iprot.readString();
12529 
            _val264 = iprot.readString();
12530 
            self.undeliveredOrders[_key263] = _val264
3064 chandransh 12531 
          iprot.readMapEnd()
12532 
        else:
12533 
          iprot.skip(ftype)
1627 ankur.sing 12534 
      else:
12535 
        iprot.skip(ftype)
12536 
      iprot.readFieldEnd()
12537 
    iprot.readStructEnd()
12538 
 
12539 
  def write(self, oprot):
12540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12542 
      return
3064 chandransh 12543 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 12544 
    if self.providerId is not None:
3064 chandransh 12545 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12546 
      oprot.writeI64(self.providerId)
1627 ankur.sing 12547 
      oprot.writeFieldEnd()
3431 rajveer 12548 
    if self.undeliveredOrders is not None:
3064 chandransh 12549 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
12550 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
5031 varun.gupt 12551 
      for kiter265,viter266 in self.undeliveredOrders.items():
12552 
        oprot.writeString(kiter265)
12553 
        oprot.writeString(viter266)
3064 chandransh 12554 
      oprot.writeMapEnd()
12555 
      oprot.writeFieldEnd()
1627 ankur.sing 12556 
    oprot.writeFieldStop()
12557 
    oprot.writeStructEnd()
12558 
 
3431 rajveer 12559 
  def validate(self):
12560 
    return
12561 
 
12562 
 
1627 ankur.sing 12563 
  def __repr__(self):
12564 
    L = ['%s=%r' % (key, value)
12565 
      for key, value in self.__dict__.iteritems()]
12566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12567 
 
12568 
  def __eq__(self, other):
12569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12570 
 
12571 
  def __ne__(self, other):
12572 
    return not (self == other)
12573 
 
3064 chandransh 12574 
class updateNonDeliveryReason_result:
1627 ankur.sing 12575 
  """
12576 
  Attributes:
3064 chandransh 12577 
   - ex
1627 ankur.sing 12578 
  """
12579 
 
12580 
  thrift_spec = (
4910 phani.kuma 12581 
    None, # 0
3064 chandransh 12582 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12583 
  )
12584 
 
4910 phani.kuma 12585 
  def __init__(self, ex=None,):
3064 chandransh 12586 
    self.ex = ex
1627 ankur.sing 12587 
 
12588 
  def read(self, iprot):
12589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12591 
      return
12592 
    iprot.readStructBegin()
12593 
    while True:
12594 
      (fname, ftype, fid) = iprot.readFieldBegin()
12595 
      if ftype == TType.STOP:
12596 
        break
4910 phani.kuma 12597 
      if fid == 1:
12598 
        if ftype == TType.STRUCT:
12599 
          self.ex = TransactionServiceException()
12600 
          self.ex.read(iprot)
12601 
        else:
12602 
          iprot.skip(ftype)
12603 
      else:
12604 
        iprot.skip(ftype)
12605 
      iprot.readFieldEnd()
12606 
    iprot.readStructEnd()
12607 
 
12608 
  def write(self, oprot):
12609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12611 
      return
12612 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
12613 
    if self.ex is not None:
12614 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12615 
      self.ex.write(oprot)
12616 
      oprot.writeFieldEnd()
12617 
    oprot.writeFieldStop()
12618 
    oprot.writeStructEnd()
12619 
 
12620 
  def validate(self):
12621 
    return
12622 
 
12623 
 
12624 
  def __repr__(self):
12625 
    L = ['%s=%r' % (key, value)
12626 
      for key, value in self.__dict__.iteritems()]
12627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12628 
 
12629 
  def __eq__(self, other):
12630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12631 
 
12632 
  def __ne__(self, other):
12633 
    return not (self == other)
12634 
 
12635 
class getNonDeliveredOrdersbyCourier_args:
12636 
  """
12637 
  Attributes:
12638 
   - providerId
12639 
  """
12640 
 
12641 
  thrift_spec = (
12642 
    None, # 0
12643 
    (1, TType.I64, 'providerId', None, None, ), # 1
12644 
  )
12645 
 
12646 
  def __init__(self, providerId=None,):
12647 
    self.providerId = providerId
12648 
 
12649 
  def read(self, iprot):
12650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12652 
      return
12653 
    iprot.readStructBegin()
12654 
    while True:
12655 
      (fname, ftype, fid) = iprot.readFieldBegin()
12656 
      if ftype == TType.STOP:
12657 
        break
12658 
      if fid == 1:
12659 
        if ftype == TType.I64:
12660 
          self.providerId = iprot.readI64();
12661 
        else:
12662 
          iprot.skip(ftype)
12663 
      else:
12664 
        iprot.skip(ftype)
12665 
      iprot.readFieldEnd()
12666 
    iprot.readStructEnd()
12667 
 
12668 
  def write(self, oprot):
12669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12671 
      return
12672 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
12673 
    if self.providerId is not None:
12674 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12675 
      oprot.writeI64(self.providerId)
12676 
      oprot.writeFieldEnd()
12677 
    oprot.writeFieldStop()
12678 
    oprot.writeStructEnd()
12679 
 
12680 
  def validate(self):
12681 
    return
12682 
 
12683 
 
12684 
  def __repr__(self):
12685 
    L = ['%s=%r' % (key, value)
12686 
      for key, value in self.__dict__.iteritems()]
12687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12688 
 
12689 
  def __eq__(self, other):
12690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12691 
 
12692 
  def __ne__(self, other):
12693 
    return not (self == other)
12694 
 
12695 
class getNonDeliveredOrdersbyCourier_result:
12696 
  """
12697 
  Attributes:
12698 
   - success
12699 
  """
12700 
 
12701 
  thrift_spec = (
12702 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12703 
  )
12704 
 
12705 
  def __init__(self, success=None,):
12706 
    self.success = success
12707 
 
12708 
  def read(self, iprot):
12709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12711 
      return
12712 
    iprot.readStructBegin()
12713 
    while True:
12714 
      (fname, ftype, fid) = iprot.readFieldBegin()
12715 
      if ftype == TType.STOP:
12716 
        break
4581 phani.kuma 12717 
      if fid == 0:
12718 
        if ftype == TType.LIST:
12719 
          self.success = []
5031 varun.gupt 12720 
          (_etype270, _size267) = iprot.readListBegin()
12721 
          for _i271 in xrange(_size267):
12722 
            _elem272 = Order()
12723 
            _elem272.read(iprot)
12724 
            self.success.append(_elem272)
4581 phani.kuma 12725 
          iprot.readListEnd()
12726 
        else:
12727 
          iprot.skip(ftype)
4910 phani.kuma 12728 
      else:
12729 
        iprot.skip(ftype)
12730 
      iprot.readFieldEnd()
12731 
    iprot.readStructEnd()
12732 
 
12733 
  def write(self, oprot):
12734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12736 
      return
12737 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
12738 
    if self.success is not None:
12739 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12740 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12741 
      for iter273 in self.success:
12742 
        iter273.write(oprot)
4910 phani.kuma 12743 
      oprot.writeListEnd()
12744 
      oprot.writeFieldEnd()
12745 
    oprot.writeFieldStop()
12746 
    oprot.writeStructEnd()
12747 
 
12748 
  def validate(self):
12749 
    return
12750 
 
12751 
 
12752 
  def __repr__(self):
12753 
    L = ['%s=%r' % (key, value)
12754 
      for key, value in self.__dict__.iteritems()]
12755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12756 
 
12757 
  def __eq__(self, other):
12758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12759 
 
12760 
  def __ne__(self, other):
12761 
    return not (self == other)
12762 
 
12763 
class markOrdersAsLocalConnected_args:
12764 
  """
12765 
  Attributes:
12766 
   - providerId
12767 
   - local_connected_orders
12768 
  """
12769 
 
12770 
  thrift_spec = (
12771 
    None, # 0
12772 
    (1, TType.I64, 'providerId', None, None, ), # 1
12773 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
12774 
  )
12775 
 
12776 
  def __init__(self, providerId=None, local_connected_orders=None,):
12777 
    self.providerId = providerId
12778 
    self.local_connected_orders = local_connected_orders
12779 
 
12780 
  def read(self, iprot):
12781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12783 
      return
12784 
    iprot.readStructBegin()
12785 
    while True:
12786 
      (fname, ftype, fid) = iprot.readFieldBegin()
12787 
      if ftype == TType.STOP:
12788 
        break
12789 
      if fid == 1:
12790 
        if ftype == TType.I64:
12791 
          self.providerId = iprot.readI64();
12792 
        else:
12793 
          iprot.skip(ftype)
12794 
      elif fid == 2:
12795 
        if ftype == TType.MAP:
12796 
          self.local_connected_orders = {}
5031 varun.gupt 12797 
          (_ktype275, _vtype276, _size274 ) = iprot.readMapBegin()
12798 
          for _i278 in xrange(_size274):
12799 
            _key279 = iprot.readString();
12800 
            _val280 = iprot.readString();
12801 
            self.local_connected_orders[_key279] = _val280
4910 phani.kuma 12802 
          iprot.readMapEnd()
12803 
        else:
12804 
          iprot.skip(ftype)
12805 
      else:
12806 
        iprot.skip(ftype)
12807 
      iprot.readFieldEnd()
12808 
    iprot.readStructEnd()
12809 
 
12810 
  def write(self, oprot):
12811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12813 
      return
12814 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
12815 
    if self.providerId is not None:
12816 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12817 
      oprot.writeI64(self.providerId)
12818 
      oprot.writeFieldEnd()
12819 
    if self.local_connected_orders is not None:
12820 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
12821 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
5031 varun.gupt 12822 
      for kiter281,viter282 in self.local_connected_orders.items():
12823 
        oprot.writeString(kiter281)
12824 
        oprot.writeString(viter282)
4910 phani.kuma 12825 
      oprot.writeMapEnd()
12826 
      oprot.writeFieldEnd()
12827 
    oprot.writeFieldStop()
12828 
    oprot.writeStructEnd()
12829 
 
12830 
  def validate(self):
12831 
    return
12832 
 
12833 
 
12834 
  def __repr__(self):
12835 
    L = ['%s=%r' % (key, value)
12836 
      for key, value in self.__dict__.iteritems()]
12837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12838 
 
12839 
  def __eq__(self, other):
12840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12841 
 
12842 
  def __ne__(self, other):
12843 
    return not (self == other)
12844 
 
12845 
class markOrdersAsLocalConnected_result:
12846 
  """
12847 
  Attributes:
12848 
   - ex
12849 
  """
12850 
 
12851 
  thrift_spec = (
12852 
    None, # 0
12853 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12854 
  )
12855 
 
12856 
  def __init__(self, ex=None,):
12857 
    self.ex = ex
12858 
 
12859 
  def read(self, iprot):
12860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12862 
      return
12863 
    iprot.readStructBegin()
12864 
    while True:
12865 
      (fname, ftype, fid) = iprot.readFieldBegin()
12866 
      if ftype == TType.STOP:
12867 
        break
12868 
      if fid == 1:
3064 chandransh 12869 
        if ftype == TType.STRUCT:
12870 
          self.ex = TransactionServiceException()
12871 
          self.ex.read(iprot)
1627 ankur.sing 12872 
        else:
12873 
          iprot.skip(ftype)
12874 
      else:
12875 
        iprot.skip(ftype)
12876 
      iprot.readFieldEnd()
12877 
    iprot.readStructEnd()
12878 
 
12879 
  def write(self, oprot):
12880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12882 
      return
4910 phani.kuma 12883 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
12884 
    if self.ex is not None:
12885 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12886 
      self.ex.write(oprot)
12887 
      oprot.writeFieldEnd()
12888 
    oprot.writeFieldStop()
12889 
    oprot.writeStructEnd()
12890 
 
12891 
  def validate(self):
12892 
    return
12893 
 
12894 
 
12895 
  def __repr__(self):
12896 
    L = ['%s=%r' % (key, value)
12897 
      for key, value in self.__dict__.iteritems()]
12898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12899 
 
12900 
  def __eq__(self, other):
12901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12902 
 
12903 
  def __ne__(self, other):
12904 
    return not (self == other)
12905 
 
12906 
class getOrdersNotLocalConnected_args:
12907 
  """
12908 
  Attributes:
12909 
   - providerId
12910 
  """
12911 
 
12912 
  thrift_spec = (
12913 
    None, # 0
12914 
    (1, TType.I64, 'providerId', None, None, ), # 1
12915 
  )
12916 
 
12917 
  def __init__(self, providerId=None,):
12918 
    self.providerId = providerId
12919 
 
12920 
  def read(self, iprot):
12921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12923 
      return
12924 
    iprot.readStructBegin()
12925 
    while True:
12926 
      (fname, ftype, fid) = iprot.readFieldBegin()
12927 
      if ftype == TType.STOP:
12928 
        break
12929 
      if fid == 1:
12930 
        if ftype == TType.I64:
12931 
          self.providerId = iprot.readI64();
12932 
        else:
12933 
          iprot.skip(ftype)
12934 
      else:
12935 
        iprot.skip(ftype)
12936 
      iprot.readFieldEnd()
12937 
    iprot.readStructEnd()
12938 
 
12939 
  def write(self, oprot):
12940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12942 
      return
12943 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
12944 
    if self.providerId is not None:
12945 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12946 
      oprot.writeI64(self.providerId)
12947 
      oprot.writeFieldEnd()
12948 
    oprot.writeFieldStop()
12949 
    oprot.writeStructEnd()
12950 
 
12951 
  def validate(self):
12952 
    return
12953 
 
12954 
 
12955 
  def __repr__(self):
12956 
    L = ['%s=%r' % (key, value)
12957 
      for key, value in self.__dict__.iteritems()]
12958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12959 
 
12960 
  def __eq__(self, other):
12961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12962 
 
12963 
  def __ne__(self, other):
12964 
    return not (self == other)
12965 
 
12966 
class getOrdersNotLocalConnected_result:
12967 
  """
12968 
  Attributes:
12969 
   - success
12970 
  """
12971 
 
12972 
  thrift_spec = (
12973 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12974 
  )
12975 
 
12976 
  def __init__(self, success=None,):
12977 
    self.success = success
12978 
 
12979 
  def read(self, iprot):
12980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12982 
      return
12983 
    iprot.readStructBegin()
12984 
    while True:
12985 
      (fname, ftype, fid) = iprot.readFieldBegin()
12986 
      if ftype == TType.STOP:
12987 
        break
12988 
      if fid == 0:
12989 
        if ftype == TType.LIST:
12990 
          self.success = []
5031 varun.gupt 12991 
          (_etype286, _size283) = iprot.readListBegin()
12992 
          for _i287 in xrange(_size283):
12993 
            _elem288 = Order()
12994 
            _elem288.read(iprot)
12995 
            self.success.append(_elem288)
4910 phani.kuma 12996 
          iprot.readListEnd()
12997 
        else:
12998 
          iprot.skip(ftype)
12999 
      else:
13000 
        iprot.skip(ftype)
13001 
      iprot.readFieldEnd()
13002 
    iprot.readStructEnd()
13003 
 
13004 
  def write(self, oprot):
13005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13007 
      return
13008 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 13009 
    if self.success is not None:
13010 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13011 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13012 
      for iter289 in self.success:
13013 
        iter289.write(oprot)
4581 phani.kuma 13014 
      oprot.writeListEnd()
13015 
      oprot.writeFieldEnd()
4910 phani.kuma 13016 
    oprot.writeFieldStop()
13017 
    oprot.writeStructEnd()
13018 
 
13019 
  def validate(self):
13020 
    return
13021 
 
13022 
 
13023 
  def __repr__(self):
13024 
    L = ['%s=%r' % (key, value)
13025 
      for key, value in self.__dict__.iteritems()]
13026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13027 
 
13028 
  def __eq__(self, other):
13029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13030 
 
13031 
  def __ne__(self, other):
13032 
    return not (self == other)
13033 
 
13034 
class markOrdersAsDestinationCityReached_args:
13035 
  """
13036 
  Attributes:
13037 
   - providerId
13038 
   - destination_city_reached_orders
13039 
  """
13040 
 
13041 
  thrift_spec = (
13042 
    None, # 0
13043 
    (1, TType.I64, 'providerId', None, None, ), # 1
13044 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13045 
  )
13046 
 
13047 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
13048 
    self.providerId = providerId
13049 
    self.destination_city_reached_orders = destination_city_reached_orders
13050 
 
13051 
  def read(self, iprot):
13052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13054 
      return
13055 
    iprot.readStructBegin()
13056 
    while True:
13057 
      (fname, ftype, fid) = iprot.readFieldBegin()
13058 
      if ftype == TType.STOP:
13059 
        break
13060 
      if fid == 1:
13061 
        if ftype == TType.I64:
13062 
          self.providerId = iprot.readI64();
13063 
        else:
13064 
          iprot.skip(ftype)
13065 
      elif fid == 2:
13066 
        if ftype == TType.MAP:
13067 
          self.destination_city_reached_orders = {}
5031 varun.gupt 13068 
          (_ktype291, _vtype292, _size290 ) = iprot.readMapBegin()
13069 
          for _i294 in xrange(_size290):
13070 
            _key295 = iprot.readString();
13071 
            _val296 = iprot.readString();
13072 
            self.destination_city_reached_orders[_key295] = _val296
4910 phani.kuma 13073 
          iprot.readMapEnd()
13074 
        else:
13075 
          iprot.skip(ftype)
13076 
      else:
13077 
        iprot.skip(ftype)
13078 
      iprot.readFieldEnd()
13079 
    iprot.readStructEnd()
13080 
 
13081 
  def write(self, oprot):
13082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13084 
      return
13085 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
13086 
    if self.providerId is not None:
13087 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13088 
      oprot.writeI64(self.providerId)
13089 
      oprot.writeFieldEnd()
13090 
    if self.destination_city_reached_orders is not None:
13091 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
13092 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
5031 varun.gupt 13093 
      for kiter297,viter298 in self.destination_city_reached_orders.items():
13094 
        oprot.writeString(kiter297)
13095 
        oprot.writeString(viter298)
4910 phani.kuma 13096 
      oprot.writeMapEnd()
13097 
      oprot.writeFieldEnd()
13098 
    oprot.writeFieldStop()
13099 
    oprot.writeStructEnd()
13100 
 
13101 
  def validate(self):
13102 
    return
13103 
 
13104 
 
13105 
  def __repr__(self):
13106 
    L = ['%s=%r' % (key, value)
13107 
      for key, value in self.__dict__.iteritems()]
13108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13109 
 
13110 
  def __eq__(self, other):
13111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13112 
 
13113 
  def __ne__(self, other):
13114 
    return not (self == other)
13115 
 
13116 
class markOrdersAsDestinationCityReached_result:
13117 
  """
13118 
  Attributes:
13119 
   - ex
13120 
  """
13121 
 
13122 
  thrift_spec = (
13123 
    None, # 0
13124 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13125 
  )
13126 
 
13127 
  def __init__(self, ex=None,):
13128 
    self.ex = ex
13129 
 
13130 
  def read(self, iprot):
13131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13133 
      return
13134 
    iprot.readStructBegin()
13135 
    while True:
13136 
      (fname, ftype, fid) = iprot.readFieldBegin()
13137 
      if ftype == TType.STOP:
13138 
        break
13139 
      if fid == 1:
13140 
        if ftype == TType.STRUCT:
13141 
          self.ex = TransactionServiceException()
13142 
          self.ex.read(iprot)
13143 
        else:
13144 
          iprot.skip(ftype)
13145 
      else:
13146 
        iprot.skip(ftype)
13147 
      iprot.readFieldEnd()
13148 
    iprot.readStructEnd()
13149 
 
13150 
  def write(self, oprot):
13151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13153 
      return
13154 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 13155 
    if self.ex is not None:
3064 chandransh 13156 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13157 
      self.ex.write(oprot)
1627 ankur.sing 13158 
      oprot.writeFieldEnd()
13159 
    oprot.writeFieldStop()
13160 
    oprot.writeStructEnd()
13161 
 
3431 rajveer 13162 
  def validate(self):
13163 
    return
13164 
 
13165 
 
1627 ankur.sing 13166 
  def __repr__(self):
13167 
    L = ['%s=%r' % (key, value)
13168 
      for key, value in self.__dict__.iteritems()]
13169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13170 
 
13171 
  def __eq__(self, other):
13172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13173 
 
13174 
  def __ne__(self, other):
13175 
    return not (self == other)
13176 
 
4910 phani.kuma 13177 
class markOrdersAsFirstDeliveryAttempted_args:
13178 
  """
13179 
  Attributes:
13180 
   - providerId
13181 
   - first_atdl_orders
13182 
  """
13183 
 
13184 
  thrift_spec = (
13185 
    None, # 0
13186 
    (1, TType.I64, 'providerId', None, None, ), # 1
13187 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13188 
  )
13189 
 
13190 
  def __init__(self, providerId=None, first_atdl_orders=None,):
13191 
    self.providerId = providerId
13192 
    self.first_atdl_orders = first_atdl_orders
13193 
 
13194 
  def read(self, iprot):
13195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13197 
      return
13198 
    iprot.readStructBegin()
13199 
    while True:
13200 
      (fname, ftype, fid) = iprot.readFieldBegin()
13201 
      if ftype == TType.STOP:
13202 
        break
13203 
      if fid == 1:
13204 
        if ftype == TType.I64:
13205 
          self.providerId = iprot.readI64();
13206 
        else:
13207 
          iprot.skip(ftype)
13208 
      elif fid == 2:
13209 
        if ftype == TType.MAP:
13210 
          self.first_atdl_orders = {}
5031 varun.gupt 13211 
          (_ktype300, _vtype301, _size299 ) = iprot.readMapBegin()
13212 
          for _i303 in xrange(_size299):
13213 
            _key304 = iprot.readString();
13214 
            _val305 = iprot.readString();
13215 
            self.first_atdl_orders[_key304] = _val305
4910 phani.kuma 13216 
          iprot.readMapEnd()
13217 
        else:
13218 
          iprot.skip(ftype)
13219 
      else:
13220 
        iprot.skip(ftype)
13221 
      iprot.readFieldEnd()
13222 
    iprot.readStructEnd()
13223 
 
13224 
  def write(self, oprot):
13225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13227 
      return
13228 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
13229 
    if self.providerId is not None:
13230 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13231 
      oprot.writeI64(self.providerId)
13232 
      oprot.writeFieldEnd()
13233 
    if self.first_atdl_orders is not None:
13234 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
13235 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
5031 varun.gupt 13236 
      for kiter306,viter307 in self.first_atdl_orders.items():
13237 
        oprot.writeString(kiter306)
13238 
        oprot.writeString(viter307)
4910 phani.kuma 13239 
      oprot.writeMapEnd()
13240 
      oprot.writeFieldEnd()
13241 
    oprot.writeFieldStop()
13242 
    oprot.writeStructEnd()
13243 
 
13244 
  def validate(self):
13245 
    return
13246 
 
13247 
 
13248 
  def __repr__(self):
13249 
    L = ['%s=%r' % (key, value)
13250 
      for key, value in self.__dict__.iteritems()]
13251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13252 
 
13253 
  def __eq__(self, other):
13254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13255 
 
13256 
  def __ne__(self, other):
13257 
    return not (self == other)
13258 
 
13259 
class markOrdersAsFirstDeliveryAttempted_result:
13260 
  """
13261 
  Attributes:
13262 
   - ex
13263 
  """
13264 
 
13265 
  thrift_spec = (
13266 
    None, # 0
13267 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13268 
  )
13269 
 
13270 
  def __init__(self, ex=None,):
13271 
    self.ex = ex
13272 
 
13273 
  def read(self, iprot):
13274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13276 
      return
13277 
    iprot.readStructBegin()
13278 
    while True:
13279 
      (fname, ftype, fid) = iprot.readFieldBegin()
13280 
      if ftype == TType.STOP:
13281 
        break
13282 
      if fid == 1:
13283 
        if ftype == TType.STRUCT:
13284 
          self.ex = TransactionServiceException()
13285 
          self.ex.read(iprot)
13286 
        else:
13287 
          iprot.skip(ftype)
13288 
      else:
13289 
        iprot.skip(ftype)
13290 
      iprot.readFieldEnd()
13291 
    iprot.readStructEnd()
13292 
 
13293 
  def write(self, oprot):
13294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13296 
      return
13297 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
13298 
    if self.ex is not None:
13299 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13300 
      self.ex.write(oprot)
13301 
      oprot.writeFieldEnd()
13302 
    oprot.writeFieldStop()
13303 
    oprot.writeStructEnd()
13304 
 
13305 
  def validate(self):
13306 
    return
13307 
 
13308 
 
13309 
  def __repr__(self):
13310 
    L = ['%s=%r' % (key, value)
13311 
      for key, value in self.__dict__.iteritems()]
13312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13313 
 
13314 
  def __eq__(self, other):
13315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13316 
 
13317 
  def __ne__(self, other):
13318 
    return not (self == other)
13319 
 
3064 chandransh 13320 
class getUndeliveredOrders_args:
1886 ankur.sing 13321 
  """
13322 
  Attributes:
3064 chandransh 13323 
   - providerId
13324 
   - warehouseId
1886 ankur.sing 13325 
  """
1627 ankur.sing 13326 
 
1886 ankur.sing 13327 
  thrift_spec = (
13328 
    None, # 0
3064 chandransh 13329 
    (1, TType.I64, 'providerId', None, None, ), # 1
13330 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 13331 
  )
13332 
 
3064 chandransh 13333 
  def __init__(self, providerId=None, warehouseId=None,):
13334 
    self.providerId = providerId
13335 
    self.warehouseId = warehouseId
1886 ankur.sing 13336 
 
13337 
  def read(self, iprot):
13338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13340 
      return
13341 
    iprot.readStructBegin()
13342 
    while True:
13343 
      (fname, ftype, fid) = iprot.readFieldBegin()
13344 
      if ftype == TType.STOP:
13345 
        break
13346 
      if fid == 1:
13347 
        if ftype == TType.I64:
3064 chandransh 13348 
          self.providerId = iprot.readI64();
1886 ankur.sing 13349 
        else:
13350 
          iprot.skip(ftype)
3064 chandransh 13351 
      elif fid == 2:
13352 
        if ftype == TType.I64:
13353 
          self.warehouseId = iprot.readI64();
13354 
        else:
13355 
          iprot.skip(ftype)
1886 ankur.sing 13356 
      else:
13357 
        iprot.skip(ftype)
13358 
      iprot.readFieldEnd()
13359 
    iprot.readStructEnd()
13360 
 
13361 
  def write(self, oprot):
13362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13364 
      return
3064 chandransh 13365 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 13366 
    if self.providerId is not None:
3064 chandransh 13367 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13368 
      oprot.writeI64(self.providerId)
1886 ankur.sing 13369 
      oprot.writeFieldEnd()
3431 rajveer 13370 
    if self.warehouseId is not None:
3064 chandransh 13371 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13372 
      oprot.writeI64(self.warehouseId)
13373 
      oprot.writeFieldEnd()
1886 ankur.sing 13374 
    oprot.writeFieldStop()
13375 
    oprot.writeStructEnd()
13376 
 
3431 rajveer 13377 
  def validate(self):
13378 
    return
13379 
 
13380 
 
1886 ankur.sing 13381 
  def __repr__(self):
13382 
    L = ['%s=%r' % (key, value)
13383 
      for key, value in self.__dict__.iteritems()]
13384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13385 
 
13386 
  def __eq__(self, other):
13387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13388 
 
13389 
  def __ne__(self, other):
13390 
    return not (self == other)
13391 
 
3064 chandransh 13392 
class getUndeliveredOrders_result:
1886 ankur.sing 13393 
  """
13394 
  Attributes:
13395 
   - success
13396 
  """
13397 
 
13398 
  thrift_spec = (
13399 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13400 
  )
13401 
 
13402 
  def __init__(self, success=None,):
13403 
    self.success = success
13404 
 
13405 
  def read(self, iprot):
13406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13408 
      return
13409 
    iprot.readStructBegin()
13410 
    while True:
13411 
      (fname, ftype, fid) = iprot.readFieldBegin()
13412 
      if ftype == TType.STOP:
13413 
        break
13414 
      if fid == 0:
13415 
        if ftype == TType.LIST:
13416 
          self.success = []
5031 varun.gupt 13417 
          (_etype311, _size308) = iprot.readListBegin()
13418 
          for _i312 in xrange(_size308):
13419 
            _elem313 = Order()
13420 
            _elem313.read(iprot)
13421 
            self.success.append(_elem313)
1886 ankur.sing 13422 
          iprot.readListEnd()
13423 
        else:
13424 
          iprot.skip(ftype)
13425 
      else:
13426 
        iprot.skip(ftype)
13427 
      iprot.readFieldEnd()
13428 
    iprot.readStructEnd()
13429 
 
13430 
  def write(self, oprot):
13431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13433 
      return
3064 chandransh 13434 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 13435 
    if self.success is not None:
1886 ankur.sing 13436 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13437 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13438 
      for iter314 in self.success:
13439 
        iter314.write(oprot)
1886 ankur.sing 13440 
      oprot.writeListEnd()
13441 
      oprot.writeFieldEnd()
13442 
    oprot.writeFieldStop()
13443 
    oprot.writeStructEnd()
13444 
 
3431 rajveer 13445 
  def validate(self):
13446 
    return
13447 
 
13448 
 
1886 ankur.sing 13449 
  def __repr__(self):
13450 
    L = ['%s=%r' % (key, value)
13451 
      for key, value in self.__dict__.iteritems()]
13452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13453 
 
13454 
  def __eq__(self, other):
13455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13456 
 
13457 
  def __ne__(self, other):
13458 
    return not (self == other)
13459 
 
4783 phani.kuma 13460 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
13461 
 
13462 
  thrift_spec = (
13463 
  )
13464 
 
13465 
  def read(self, iprot):
13466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13468 
      return
13469 
    iprot.readStructBegin()
13470 
    while True:
13471 
      (fname, ftype, fid) = iprot.readFieldBegin()
13472 
      if ftype == TType.STOP:
13473 
        break
13474 
      else:
13475 
        iprot.skip(ftype)
13476 
      iprot.readFieldEnd()
13477 
    iprot.readStructEnd()
13478 
 
13479 
  def write(self, oprot):
13480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13482 
      return
13483 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
13484 
    oprot.writeFieldStop()
13485 
    oprot.writeStructEnd()
13486 
 
13487 
  def validate(self):
13488 
    return
13489 
 
13490 
 
13491 
  def __repr__(self):
13492 
    L = ['%s=%r' % (key, value)
13493 
      for key, value in self.__dict__.iteritems()]
13494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13495 
 
13496 
  def __eq__(self, other):
13497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13498 
 
13499 
  def __ne__(self, other):
13500 
    return not (self == other)
13501 
 
13502 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
13503 
  """
13504 
  Attributes:
13505 
   - success
13506 
  """
13507 
 
13508 
  thrift_spec = (
13509 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13510 
  )
13511 
 
13512 
  def __init__(self, success=None,):
13513 
    self.success = success
13514 
 
13515 
  def read(self, iprot):
13516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13518 
      return
13519 
    iprot.readStructBegin()
13520 
    while True:
13521 
      (fname, ftype, fid) = iprot.readFieldBegin()
13522 
      if ftype == TType.STOP:
13523 
        break
13524 
      if fid == 0:
13525 
        if ftype == TType.LIST:
13526 
          self.success = []
5031 varun.gupt 13527 
          (_etype318, _size315) = iprot.readListBegin()
13528 
          for _i319 in xrange(_size315):
13529 
            _elem320 = Order()
13530 
            _elem320.read(iprot)
13531 
            self.success.append(_elem320)
4783 phani.kuma 13532 
          iprot.readListEnd()
13533 
        else:
13534 
          iprot.skip(ftype)
13535 
      else:
13536 
        iprot.skip(ftype)
13537 
      iprot.readFieldEnd()
13538 
    iprot.readStructEnd()
13539 
 
13540 
  def write(self, oprot):
13541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13543 
      return
13544 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
13545 
    if self.success is not None:
13546 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13547 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13548 
      for iter321 in self.success:
13549 
        iter321.write(oprot)
4783 phani.kuma 13550 
      oprot.writeListEnd()
13551 
      oprot.writeFieldEnd()
13552 
    oprot.writeFieldStop()
13553 
    oprot.writeStructEnd()
13554 
 
13555 
  def validate(self):
13556 
    return
13557 
 
13558 
 
13559 
  def __repr__(self):
13560 
    L = ['%s=%r' % (key, value)
13561 
      for key, value in self.__dict__.iteritems()]
13562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13563 
 
13564 
  def __eq__(self, other):
13565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13566 
 
13567 
  def __ne__(self, other):
13568 
    return not (self == other)
13569 
 
2536 chandransh 13570 
class toggleDOAFlag_args:
13571 
  """
13572 
  Attributes:
13573 
   - orderId
13574 
  """
1886 ankur.sing 13575 
 
2536 chandransh 13576 
  thrift_spec = (
13577 
    None, # 0
13578 
    (1, TType.I64, 'orderId', None, None, ), # 1
13579 
  )
13580 
 
13581 
  def __init__(self, orderId=None,):
13582 
    self.orderId = orderId
13583 
 
13584 
  def read(self, iprot):
13585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13587 
      return
13588 
    iprot.readStructBegin()
13589 
    while True:
13590 
      (fname, ftype, fid) = iprot.readFieldBegin()
13591 
      if ftype == TType.STOP:
13592 
        break
13593 
      if fid == 1:
13594 
        if ftype == TType.I64:
13595 
          self.orderId = iprot.readI64();
13596 
        else:
13597 
          iprot.skip(ftype)
13598 
      else:
13599 
        iprot.skip(ftype)
13600 
      iprot.readFieldEnd()
13601 
    iprot.readStructEnd()
13602 
 
13603 
  def write(self, oprot):
13604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13606 
      return
13607 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 13608 
    if self.orderId is not None:
2536 chandransh 13609 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13610 
      oprot.writeI64(self.orderId)
13611 
      oprot.writeFieldEnd()
13612 
    oprot.writeFieldStop()
13613 
    oprot.writeStructEnd()
13614 
 
3431 rajveer 13615 
  def validate(self):
13616 
    return
13617 
 
13618 
 
2536 chandransh 13619 
  def __repr__(self):
13620 
    L = ['%s=%r' % (key, value)
13621 
      for key, value in self.__dict__.iteritems()]
13622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13623 
 
13624 
  def __eq__(self, other):
13625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13626 
 
13627 
  def __ne__(self, other):
13628 
    return not (self == other)
13629 
 
13630 
class toggleDOAFlag_result:
13631 
  """
13632 
  Attributes:
13633 
   - success
13634 
   - ex
13635 
  """
13636 
 
13637 
  thrift_spec = (
13638 
    (0, TType.BOOL, 'success', None, None, ), # 0
13639 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13640 
  )
13641 
 
13642 
  def __init__(self, success=None, ex=None,):
13643 
    self.success = success
13644 
    self.ex = ex
13645 
 
13646 
  def read(self, iprot):
13647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13649 
      return
13650 
    iprot.readStructBegin()
13651 
    while True:
13652 
      (fname, ftype, fid) = iprot.readFieldBegin()
13653 
      if ftype == TType.STOP:
13654 
        break
13655 
      if fid == 0:
13656 
        if ftype == TType.BOOL:
13657 
          self.success = iprot.readBool();
13658 
        else:
13659 
          iprot.skip(ftype)
13660 
      elif fid == 1:
13661 
        if ftype == TType.STRUCT:
13662 
          self.ex = TransactionServiceException()
13663 
          self.ex.read(iprot)
13664 
        else:
13665 
          iprot.skip(ftype)
13666 
      else:
13667 
        iprot.skip(ftype)
13668 
      iprot.readFieldEnd()
13669 
    iprot.readStructEnd()
13670 
 
13671 
  def write(self, oprot):
13672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13674 
      return
13675 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 13676 
    if self.success is not None:
2536 chandransh 13677 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13678 
      oprot.writeBool(self.success)
13679 
      oprot.writeFieldEnd()
3431 rajveer 13680 
    if self.ex is not None:
2536 chandransh 13681 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13682 
      self.ex.write(oprot)
13683 
      oprot.writeFieldEnd()
13684 
    oprot.writeFieldStop()
13685 
    oprot.writeStructEnd()
13686 
 
3431 rajveer 13687 
  def validate(self):
13688 
    return
13689 
 
13690 
 
2536 chandransh 13691 
  def __repr__(self):
13692 
    L = ['%s=%r' % (key, value)
13693 
      for key, value in self.__dict__.iteritems()]
13694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13695 
 
13696 
  def __eq__(self, other):
13697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13698 
 
13699 
  def __ne__(self, other):
13700 
    return not (self == other)
13701 
 
4712 rajveer 13702 
class markOrderAsDelivered_args:
13703 
  """
13704 
  Attributes:
13705 
   - orderId
13706 
   - deliveryTimestamp
13707 
   - receiver
13708 
  """
13709 
 
13710 
  thrift_spec = None
13711 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
13712 
    self.orderId = orderId
13713 
    self.deliveryTimestamp = deliveryTimestamp
13714 
    self.receiver = receiver
13715 
 
13716 
  def read(self, iprot):
13717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13719 
      return
13720 
    iprot.readStructBegin()
13721 
    while True:
13722 
      (fname, ftype, fid) = iprot.readFieldBegin()
13723 
      if ftype == TType.STOP:
13724 
        break
13725 
      if fid == 1:
13726 
        if ftype == TType.I64:
13727 
          self.orderId = iprot.readI64();
13728 
        else:
13729 
          iprot.skip(ftype)
13730 
      elif fid == 2:
13731 
        if ftype == TType.I64:
13732 
          self.deliveryTimestamp = iprot.readI64();
13733 
        else:
13734 
          iprot.skip(ftype)
13735 
      elif fid == -1:
13736 
        if ftype == TType.STRING:
13737 
          self.receiver = iprot.readString();
13738 
        else:
13739 
          iprot.skip(ftype)
13740 
      else:
13741 
        iprot.skip(ftype)
13742 
      iprot.readFieldEnd()
13743 
    iprot.readStructEnd()
13744 
 
13745 
  def write(self, oprot):
13746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13748 
      return
13749 
    oprot.writeStructBegin('markOrderAsDelivered_args')
13750 
    if self.receiver is not None:
13751 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
13752 
      oprot.writeString(self.receiver)
13753 
      oprot.writeFieldEnd()
13754 
    if self.orderId is not None:
13755 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13756 
      oprot.writeI64(self.orderId)
13757 
      oprot.writeFieldEnd()
13758 
    if self.deliveryTimestamp is not None:
13759 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
13760 
      oprot.writeI64(self.deliveryTimestamp)
13761 
      oprot.writeFieldEnd()
13762 
    oprot.writeFieldStop()
13763 
    oprot.writeStructEnd()
13764 
 
13765 
  def validate(self):
13766 
    return
13767 
 
13768 
 
13769 
  def __repr__(self):
13770 
    L = ['%s=%r' % (key, value)
13771 
      for key, value in self.__dict__.iteritems()]
13772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13773 
 
13774 
  def __eq__(self, other):
13775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13776 
 
13777 
  def __ne__(self, other):
13778 
    return not (self == other)
13779 
 
13780 
class markOrderAsDelivered_result:
13781 
  """
13782 
  Attributes:
13783 
   - ex
13784 
  """
13785 
 
13786 
  thrift_spec = (
13787 
    None, # 0
13788 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13789 
  )
13790 
 
13791 
  def __init__(self, ex=None,):
13792 
    self.ex = ex
13793 
 
13794 
  def read(self, iprot):
13795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13797 
      return
13798 
    iprot.readStructBegin()
13799 
    while True:
13800 
      (fname, ftype, fid) = iprot.readFieldBegin()
13801 
      if ftype == TType.STOP:
13802 
        break
13803 
      if fid == 1:
13804 
        if ftype == TType.STRUCT:
13805 
          self.ex = TransactionServiceException()
13806 
          self.ex.read(iprot)
13807 
        else:
13808 
          iprot.skip(ftype)
13809 
      else:
13810 
        iprot.skip(ftype)
13811 
      iprot.readFieldEnd()
13812 
    iprot.readStructEnd()
13813 
 
13814 
  def write(self, oprot):
13815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13817 
      return
13818 
    oprot.writeStructBegin('markOrderAsDelivered_result')
13819 
    if self.ex is not None:
13820 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13821 
      self.ex.write(oprot)
13822 
      oprot.writeFieldEnd()
13823 
    oprot.writeFieldStop()
13824 
    oprot.writeStructEnd()
13825 
 
13826 
  def validate(self):
13827 
    return
13828 
 
13829 
 
13830 
  def __repr__(self):
13831 
    L = ['%s=%r' % (key, value)
13832 
      for key, value in self.__dict__.iteritems()]
13833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13834 
 
13835 
  def __eq__(self, other):
13836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13837 
 
13838 
  def __ne__(self, other):
13839 
    return not (self == other)
13840 
 
4454 rajveer 13841 
class markOrderDoaRequestReceived_args:
13842 
  """
13843 
  Attributes:
13844 
   - orderId
13845 
  """
13846 
 
13847 
  thrift_spec = (
13848 
    None, # 0
13849 
    (1, TType.I64, 'orderId', None, None, ), # 1
13850 
  )
13851 
 
13852 
  def __init__(self, orderId=None,):
13853 
    self.orderId = orderId
13854 
 
13855 
  def read(self, iprot):
13856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13858 
      return
13859 
    iprot.readStructBegin()
13860 
    while True:
13861 
      (fname, ftype, fid) = iprot.readFieldBegin()
13862 
      if ftype == TType.STOP:
13863 
        break
13864 
      if fid == 1:
13865 
        if ftype == TType.I64:
13866 
          self.orderId = iprot.readI64();
13867 
        else:
13868 
          iprot.skip(ftype)
13869 
      else:
13870 
        iprot.skip(ftype)
13871 
      iprot.readFieldEnd()
13872 
    iprot.readStructEnd()
13873 
 
13874 
  def write(self, oprot):
13875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13877 
      return
13878 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
13879 
    if self.orderId is not None:
13880 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13881 
      oprot.writeI64(self.orderId)
13882 
      oprot.writeFieldEnd()
13883 
    oprot.writeFieldStop()
13884 
    oprot.writeStructEnd()
13885 
 
13886 
  def validate(self):
13887 
    return
13888 
 
13889 
 
13890 
  def __repr__(self):
13891 
    L = ['%s=%r' % (key, value)
13892 
      for key, value in self.__dict__.iteritems()]
13893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13894 
 
13895 
  def __eq__(self, other):
13896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13897 
 
13898 
  def __ne__(self, other):
13899 
    return not (self == other)
13900 
 
13901 
class markOrderDoaRequestReceived_result:
13902 
  """
13903 
  Attributes:
13904 
   - success
13905 
   - ex
13906 
  """
13907 
 
13908 
  thrift_spec = (
13909 
    (0, TType.BOOL, 'success', None, None, ), # 0
13910 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13911 
  )
13912 
 
13913 
  def __init__(self, success=None, ex=None,):
13914 
    self.success = success
13915 
    self.ex = ex
13916 
 
13917 
  def read(self, iprot):
13918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13920 
      return
13921 
    iprot.readStructBegin()
13922 
    while True:
13923 
      (fname, ftype, fid) = iprot.readFieldBegin()
13924 
      if ftype == TType.STOP:
13925 
        break
13926 
      if fid == 0:
13927 
        if ftype == TType.BOOL:
13928 
          self.success = iprot.readBool();
13929 
        else:
13930 
          iprot.skip(ftype)
13931 
      elif fid == 1:
13932 
        if ftype == TType.STRUCT:
13933 
          self.ex = TransactionServiceException()
13934 
          self.ex.read(iprot)
13935 
        else:
13936 
          iprot.skip(ftype)
13937 
      else:
13938 
        iprot.skip(ftype)
13939 
      iprot.readFieldEnd()
13940 
    iprot.readStructEnd()
13941 
 
13942 
  def write(self, oprot):
13943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13945 
      return
13946 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
13947 
    if self.success is not None:
13948 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13949 
      oprot.writeBool(self.success)
13950 
      oprot.writeFieldEnd()
13951 
    if self.ex is not None:
13952 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13953 
      self.ex.write(oprot)
13954 
      oprot.writeFieldEnd()
13955 
    oprot.writeFieldStop()
13956 
    oprot.writeStructEnd()
13957 
 
13958 
  def validate(self):
13959 
    return
13960 
 
13961 
 
13962 
  def __repr__(self):
13963 
    L = ['%s=%r' % (key, value)
13964 
      for key, value in self.__dict__.iteritems()]
13965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13966 
 
13967 
  def __eq__(self, other):
13968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13969 
 
13970 
  def __ne__(self, other):
13971 
    return not (self == other)
13972 
 
13973 
class markOrderDoaRequestAuthorized_args:
13974 
  """
13975 
  Attributes:
13976 
   - orderId
13977 
   - isAuthorized
13978 
  """
13979 
 
13980 
  thrift_spec = (
13981 
    None, # 0
13982 
    (1, TType.I64, 'orderId', None, None, ), # 1
13983 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
13984 
  )
13985 
 
13986 
  def __init__(self, orderId=None, isAuthorized=None,):
13987 
    self.orderId = orderId
13988 
    self.isAuthorized = isAuthorized
13989 
 
13990 
  def read(self, iprot):
13991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13993 
      return
13994 
    iprot.readStructBegin()
13995 
    while True:
13996 
      (fname, ftype, fid) = iprot.readFieldBegin()
13997 
      if ftype == TType.STOP:
13998 
        break
13999 
      if fid == 1:
14000 
        if ftype == TType.I64:
14001 
          self.orderId = iprot.readI64();
14002 
        else:
14003 
          iprot.skip(ftype)
14004 
      elif fid == 2:
14005 
        if ftype == TType.BOOL:
14006 
          self.isAuthorized = iprot.readBool();
14007 
        else:
14008 
          iprot.skip(ftype)
14009 
      else:
14010 
        iprot.skip(ftype)
14011 
      iprot.readFieldEnd()
14012 
    iprot.readStructEnd()
14013 
 
14014 
  def write(self, oprot):
14015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14017 
      return
14018 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
14019 
    if self.orderId is not None:
14020 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14021 
      oprot.writeI64(self.orderId)
14022 
      oprot.writeFieldEnd()
14023 
    if self.isAuthorized is not None:
14024 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14025 
      oprot.writeBool(self.isAuthorized)
14026 
      oprot.writeFieldEnd()
14027 
    oprot.writeFieldStop()
14028 
    oprot.writeStructEnd()
14029 
 
14030 
  def validate(self):
14031 
    return
14032 
 
14033 
 
14034 
  def __repr__(self):
14035 
    L = ['%s=%r' % (key, value)
14036 
      for key, value in self.__dict__.iteritems()]
14037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14038 
 
14039 
  def __eq__(self, other):
14040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14041 
 
14042 
  def __ne__(self, other):
14043 
    return not (self == other)
14044 
 
14045 
class markOrderDoaRequestAuthorized_result:
14046 
  """
14047 
  Attributes:
14048 
   - success
14049 
   - ex
14050 
  """
14051 
 
14052 
  thrift_spec = (
14053 
    (0, TType.BOOL, 'success', None, None, ), # 0
14054 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14055 
  )
14056 
 
14057 
  def __init__(self, success=None, ex=None,):
14058 
    self.success = success
14059 
    self.ex = ex
14060 
 
14061 
  def read(self, iprot):
14062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14064 
      return
14065 
    iprot.readStructBegin()
14066 
    while True:
14067 
      (fname, ftype, fid) = iprot.readFieldBegin()
14068 
      if ftype == TType.STOP:
14069 
        break
14070 
      if fid == 0:
14071 
        if ftype == TType.BOOL:
14072 
          self.success = iprot.readBool();
14073 
        else:
14074 
          iprot.skip(ftype)
14075 
      elif fid == 1:
14076 
        if ftype == TType.STRUCT:
14077 
          self.ex = TransactionServiceException()
14078 
          self.ex.read(iprot)
14079 
        else:
14080 
          iprot.skip(ftype)
14081 
      else:
14082 
        iprot.skip(ftype)
14083 
      iprot.readFieldEnd()
14084 
    iprot.readStructEnd()
14085 
 
14086 
  def write(self, oprot):
14087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14089 
      return
14090 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
14091 
    if self.success is not None:
14092 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14093 
      oprot.writeBool(self.success)
14094 
      oprot.writeFieldEnd()
14095 
    if self.ex is not None:
14096 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14097 
      self.ex.write(oprot)
14098 
      oprot.writeFieldEnd()
14099 
    oprot.writeFieldStop()
14100 
    oprot.writeStructEnd()
14101 
 
14102 
  def validate(self):
14103 
    return
14104 
 
14105 
 
14106 
  def __repr__(self):
14107 
    L = ['%s=%r' % (key, value)
14108 
      for key, value in self.__dict__.iteritems()]
14109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14110 
 
14111 
  def __eq__(self, other):
14112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14113 
 
14114 
  def __ne__(self, other):
14115 
    return not (self == other)
14116 
 
4488 rajveer 14117 
class markOrderReturnRequestReceived_args:
14118 
  """
14119 
  Attributes:
14120 
   - orderId
14121 
  """
14122 
 
14123 
  thrift_spec = (
14124 
    None, # 0
14125 
    (1, TType.I64, 'orderId', None, None, ), # 1
14126 
  )
14127 
 
14128 
  def __init__(self, orderId=None,):
14129 
    self.orderId = orderId
14130 
 
14131 
  def read(self, iprot):
14132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14134 
      return
14135 
    iprot.readStructBegin()
14136 
    while True:
14137 
      (fname, ftype, fid) = iprot.readFieldBegin()
14138 
      if ftype == TType.STOP:
14139 
        break
14140 
      if fid == 1:
14141 
        if ftype == TType.I64:
14142 
          self.orderId = iprot.readI64();
14143 
        else:
14144 
          iprot.skip(ftype)
14145 
      else:
14146 
        iprot.skip(ftype)
14147 
      iprot.readFieldEnd()
14148 
    iprot.readStructEnd()
14149 
 
14150 
  def write(self, oprot):
14151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14153 
      return
14154 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
14155 
    if self.orderId is not None:
14156 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14157 
      oprot.writeI64(self.orderId)
14158 
      oprot.writeFieldEnd()
14159 
    oprot.writeFieldStop()
14160 
    oprot.writeStructEnd()
14161 
 
14162 
  def validate(self):
14163 
    return
14164 
 
14165 
 
14166 
  def __repr__(self):
14167 
    L = ['%s=%r' % (key, value)
14168 
      for key, value in self.__dict__.iteritems()]
14169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14170 
 
14171 
  def __eq__(self, other):
14172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14173 
 
14174 
  def __ne__(self, other):
14175 
    return not (self == other)
14176 
 
14177 
class markOrderReturnRequestReceived_result:
14178 
  """
14179 
  Attributes:
14180 
   - success
14181 
   - ex
14182 
  """
14183 
 
14184 
  thrift_spec = (
14185 
    (0, TType.BOOL, 'success', None, None, ), # 0
14186 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14187 
  )
14188 
 
14189 
  def __init__(self, success=None, ex=None,):
14190 
    self.success = success
14191 
    self.ex = ex
14192 
 
14193 
  def read(self, iprot):
14194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14196 
      return
14197 
    iprot.readStructBegin()
14198 
    while True:
14199 
      (fname, ftype, fid) = iprot.readFieldBegin()
14200 
      if ftype == TType.STOP:
14201 
        break
14202 
      if fid == 0:
14203 
        if ftype == TType.BOOL:
14204 
          self.success = iprot.readBool();
14205 
        else:
14206 
          iprot.skip(ftype)
14207 
      elif fid == 1:
14208 
        if ftype == TType.STRUCT:
14209 
          self.ex = TransactionServiceException()
14210 
          self.ex.read(iprot)
14211 
        else:
14212 
          iprot.skip(ftype)
14213 
      else:
14214 
        iprot.skip(ftype)
14215 
      iprot.readFieldEnd()
14216 
    iprot.readStructEnd()
14217 
 
14218 
  def write(self, oprot):
14219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14221 
      return
14222 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
14223 
    if self.success is not None:
14224 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14225 
      oprot.writeBool(self.success)
14226 
      oprot.writeFieldEnd()
14227 
    if self.ex is not None:
14228 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14229 
      self.ex.write(oprot)
14230 
      oprot.writeFieldEnd()
14231 
    oprot.writeFieldStop()
14232 
    oprot.writeStructEnd()
14233 
 
14234 
  def validate(self):
14235 
    return
14236 
 
14237 
 
14238 
  def __repr__(self):
14239 
    L = ['%s=%r' % (key, value)
14240 
      for key, value in self.__dict__.iteritems()]
14241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14242 
 
14243 
  def __eq__(self, other):
14244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14245 
 
14246 
  def __ne__(self, other):
14247 
    return not (self == other)
14248 
 
14249 
class markOrderReturnRequestAuthorized_args:
14250 
  """
14251 
  Attributes:
14252 
   - orderId
14253 
   - isAuthorized
14254 
  """
14255 
 
14256 
  thrift_spec = (
14257 
    None, # 0
14258 
    (1, TType.I64, 'orderId', None, None, ), # 1
14259 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14260 
  )
14261 
 
14262 
  def __init__(self, orderId=None, isAuthorized=None,):
14263 
    self.orderId = orderId
14264 
    self.isAuthorized = isAuthorized
14265 
 
14266 
  def read(self, iprot):
14267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14269 
      return
14270 
    iprot.readStructBegin()
14271 
    while True:
14272 
      (fname, ftype, fid) = iprot.readFieldBegin()
14273 
      if ftype == TType.STOP:
14274 
        break
14275 
      if fid == 1:
14276 
        if ftype == TType.I64:
14277 
          self.orderId = iprot.readI64();
14278 
        else:
14279 
          iprot.skip(ftype)
14280 
      elif fid == 2:
14281 
        if ftype == TType.BOOL:
14282 
          self.isAuthorized = iprot.readBool();
14283 
        else:
14284 
          iprot.skip(ftype)
14285 
      else:
14286 
        iprot.skip(ftype)
14287 
      iprot.readFieldEnd()
14288 
    iprot.readStructEnd()
14289 
 
14290 
  def write(self, oprot):
14291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14293 
      return
14294 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
14295 
    if self.orderId is not None:
14296 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14297 
      oprot.writeI64(self.orderId)
14298 
      oprot.writeFieldEnd()
14299 
    if self.isAuthorized is not None:
14300 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14301 
      oprot.writeBool(self.isAuthorized)
14302 
      oprot.writeFieldEnd()
14303 
    oprot.writeFieldStop()
14304 
    oprot.writeStructEnd()
14305 
 
14306 
  def validate(self):
14307 
    return
14308 
 
14309 
 
14310 
  def __repr__(self):
14311 
    L = ['%s=%r' % (key, value)
14312 
      for key, value in self.__dict__.iteritems()]
14313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14314 
 
14315 
  def __eq__(self, other):
14316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14317 
 
14318 
  def __ne__(self, other):
14319 
    return not (self == other)
14320 
 
14321 
class markOrderReturnRequestAuthorized_result:
14322 
  """
14323 
  Attributes:
14324 
   - success
14325 
   - ex
14326 
  """
14327 
 
14328 
  thrift_spec = (
14329 
    (0, TType.BOOL, 'success', None, None, ), # 0
14330 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14331 
  )
14332 
 
14333 
  def __init__(self, success=None, ex=None,):
14334 
    self.success = success
14335 
    self.ex = ex
14336 
 
14337 
  def read(self, iprot):
14338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14340 
      return
14341 
    iprot.readStructBegin()
14342 
    while True:
14343 
      (fname, ftype, fid) = iprot.readFieldBegin()
14344 
      if ftype == TType.STOP:
14345 
        break
14346 
      if fid == 0:
14347 
        if ftype == TType.BOOL:
14348 
          self.success = iprot.readBool();
14349 
        else:
14350 
          iprot.skip(ftype)
14351 
      elif fid == 1:
14352 
        if ftype == TType.STRUCT:
14353 
          self.ex = TransactionServiceException()
14354 
          self.ex.read(iprot)
14355 
        else:
14356 
          iprot.skip(ftype)
14357 
      else:
14358 
        iprot.skip(ftype)
14359 
      iprot.readFieldEnd()
14360 
    iprot.readStructEnd()
14361 
 
14362 
  def write(self, oprot):
14363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14365 
      return
14366 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
14367 
    if self.success is not None:
14368 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14369 
      oprot.writeBool(self.success)
14370 
      oprot.writeFieldEnd()
14371 
    if self.ex is not None:
14372 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14373 
      self.ex.write(oprot)
14374 
      oprot.writeFieldEnd()
14375 
    oprot.writeFieldStop()
14376 
    oprot.writeStructEnd()
14377 
 
14378 
  def validate(self):
14379 
    return
14380 
 
14381 
 
14382 
  def __repr__(self):
14383 
    L = ['%s=%r' % (key, value)
14384 
      for key, value in self.__dict__.iteritems()]
14385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14386 
 
14387 
  def __eq__(self, other):
14388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14389 
 
14390 
  def __ne__(self, other):
14391 
    return not (self == other)
14392 
 
2536 chandransh 14393 
class requestPickupNumber_args:
14394 
  """
14395 
  Attributes:
14396 
   - orderId
4579 rajveer 14397 
   - providerId
2536 chandransh 14398 
  """
14399 
 
14400 
  thrift_spec = (
14401 
    None, # 0
14402 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 14403 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 14404 
  )
14405 
 
4579 rajveer 14406 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 14407 
    self.orderId = orderId
4579 rajveer 14408 
    self.providerId = providerId
2536 chandransh 14409 
 
14410 
  def read(self, iprot):
14411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14413 
      return
14414 
    iprot.readStructBegin()
14415 
    while True:
14416 
      (fname, ftype, fid) = iprot.readFieldBegin()
14417 
      if ftype == TType.STOP:
14418 
        break
14419 
      if fid == 1:
14420 
        if ftype == TType.I64:
14421 
          self.orderId = iprot.readI64();
14422 
        else:
14423 
          iprot.skip(ftype)
4579 rajveer 14424 
      elif fid == 2:
14425 
        if ftype == TType.I64:
14426 
          self.providerId = iprot.readI64();
14427 
        else:
14428 
          iprot.skip(ftype)
2536 chandransh 14429 
      else:
14430 
        iprot.skip(ftype)
14431 
      iprot.readFieldEnd()
14432 
    iprot.readStructEnd()
14433 
 
14434 
  def write(self, oprot):
14435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14437 
      return
14438 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 14439 
    if self.orderId is not None:
2536 chandransh 14440 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14441 
      oprot.writeI64(self.orderId)
14442 
      oprot.writeFieldEnd()
4579 rajveer 14443 
    if self.providerId is not None:
14444 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
14445 
      oprot.writeI64(self.providerId)
14446 
      oprot.writeFieldEnd()
2536 chandransh 14447 
    oprot.writeFieldStop()
14448 
    oprot.writeStructEnd()
14449 
 
3431 rajveer 14450 
  def validate(self):
14451 
    return
14452 
 
14453 
 
2536 chandransh 14454 
  def __repr__(self):
14455 
    L = ['%s=%r' % (key, value)
14456 
      for key, value in self.__dict__.iteritems()]
14457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14458 
 
14459 
  def __eq__(self, other):
14460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14461 
 
14462 
  def __ne__(self, other):
14463 
    return not (self == other)
14464 
 
14465 
class requestPickupNumber_result:
14466 
  """
14467 
  Attributes:
14468 
   - success
14469 
   - ex
14470 
  """
14471 
 
14472 
  thrift_spec = (
14473 
    (0, TType.BOOL, 'success', None, None, ), # 0
14474 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14475 
  )
14476 
 
14477 
  def __init__(self, success=None, ex=None,):
14478 
    self.success = success
14479 
    self.ex = ex
14480 
 
14481 
  def read(self, iprot):
14482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14484 
      return
14485 
    iprot.readStructBegin()
14486 
    while True:
14487 
      (fname, ftype, fid) = iprot.readFieldBegin()
14488 
      if ftype == TType.STOP:
14489 
        break
14490 
      if fid == 0:
14491 
        if ftype == TType.BOOL:
14492 
          self.success = iprot.readBool();
14493 
        else:
14494 
          iprot.skip(ftype)
14495 
      elif fid == 1:
14496 
        if ftype == TType.STRUCT:
14497 
          self.ex = TransactionServiceException()
14498 
          self.ex.read(iprot)
14499 
        else:
14500 
          iprot.skip(ftype)
14501 
      else:
14502 
        iprot.skip(ftype)
14503 
      iprot.readFieldEnd()
14504 
    iprot.readStructEnd()
14505 
 
14506 
  def write(self, oprot):
14507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14509 
      return
14510 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 14511 
    if self.success is not None:
2536 chandransh 14512 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14513 
      oprot.writeBool(self.success)
14514 
      oprot.writeFieldEnd()
3431 rajveer 14515 
    if self.ex is not None:
2536 chandransh 14516 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14517 
      self.ex.write(oprot)
14518 
      oprot.writeFieldEnd()
14519 
    oprot.writeFieldStop()
14520 
    oprot.writeStructEnd()
14521 
 
3431 rajveer 14522 
  def validate(self):
14523 
    return
14524 
 
14525 
 
2536 chandransh 14526 
  def __repr__(self):
14527 
    L = ['%s=%r' % (key, value)
14528 
      for key, value in self.__dict__.iteritems()]
14529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14530 
 
14531 
  def __eq__(self, other):
14532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14533 
 
14534 
  def __ne__(self, other):
14535 
    return not (self == other)
14536 
 
14537 
class authorizePickup_args:
14538 
  """
14539 
  Attributes:
14540 
   - orderId
14541 
   - pickupNumber
4602 rajveer 14542 
   - providerId
2536 chandransh 14543 
  """
14544 
 
14545 
  thrift_spec = (
14546 
    None, # 0
14547 
    (1, TType.I64, 'orderId', None, None, ), # 1
14548 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 14549 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 14550 
  )
14551 
 
4602 rajveer 14552 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 14553 
    self.orderId = orderId
14554 
    self.pickupNumber = pickupNumber
4602 rajveer 14555 
    self.providerId = providerId
2536 chandransh 14556 
 
14557 
  def read(self, iprot):
14558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14560 
      return
14561 
    iprot.readStructBegin()
14562 
    while True:
14563 
      (fname, ftype, fid) = iprot.readFieldBegin()
14564 
      if ftype == TType.STOP:
14565 
        break
14566 
      if fid == 1:
14567 
        if ftype == TType.I64:
14568 
          self.orderId = iprot.readI64();
14569 
        else:
14570 
          iprot.skip(ftype)
14571 
      elif fid == 2:
14572 
        if ftype == TType.STRING:
14573 
          self.pickupNumber = iprot.readString();
14574 
        else:
14575 
          iprot.skip(ftype)
4602 rajveer 14576 
      elif fid == 3:
14577 
        if ftype == TType.I64:
14578 
          self.providerId = iprot.readI64();
14579 
        else:
14580 
          iprot.skip(ftype)
2536 chandransh 14581 
      else:
14582 
        iprot.skip(ftype)
14583 
      iprot.readFieldEnd()
14584 
    iprot.readStructEnd()
14585 
 
14586 
  def write(self, oprot):
14587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14589 
      return
14590 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 14591 
    if self.orderId is not None:
2536 chandransh 14592 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14593 
      oprot.writeI64(self.orderId)
14594 
      oprot.writeFieldEnd()
3431 rajveer 14595 
    if self.pickupNumber is not None:
2536 chandransh 14596 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
14597 
      oprot.writeString(self.pickupNumber)
14598 
      oprot.writeFieldEnd()
4602 rajveer 14599 
    if self.providerId is not None:
14600 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
14601 
      oprot.writeI64(self.providerId)
14602 
      oprot.writeFieldEnd()
2536 chandransh 14603 
    oprot.writeFieldStop()
14604 
    oprot.writeStructEnd()
14605 
 
3431 rajveer 14606 
  def validate(self):
14607 
    return
14608 
 
14609 
 
2536 chandransh 14610 
  def __repr__(self):
14611 
    L = ['%s=%r' % (key, value)
14612 
      for key, value in self.__dict__.iteritems()]
14613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14614 
 
14615 
  def __eq__(self, other):
14616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14617 
 
14618 
  def __ne__(self, other):
14619 
    return not (self == other)
14620 
 
14621 
class authorizePickup_result:
14622 
  """
14623 
  Attributes:
14624 
   - success
14625 
   - ex
14626 
  """
14627 
 
14628 
  thrift_spec = (
14629 
    (0, TType.BOOL, 'success', None, None, ), # 0
14630 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14631 
  )
14632 
 
14633 
  def __init__(self, success=None, ex=None,):
14634 
    self.success = success
14635 
    self.ex = ex
14636 
 
14637 
  def read(self, iprot):
14638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14640 
      return
14641 
    iprot.readStructBegin()
14642 
    while True:
14643 
      (fname, ftype, fid) = iprot.readFieldBegin()
14644 
      if ftype == TType.STOP:
14645 
        break
14646 
      if fid == 0:
14647 
        if ftype == TType.BOOL:
14648 
          self.success = iprot.readBool();
14649 
        else:
14650 
          iprot.skip(ftype)
14651 
      elif fid == 1:
14652 
        if ftype == TType.STRUCT:
14653 
          self.ex = TransactionServiceException()
14654 
          self.ex.read(iprot)
14655 
        else:
14656 
          iprot.skip(ftype)
14657 
      else:
14658 
        iprot.skip(ftype)
14659 
      iprot.readFieldEnd()
14660 
    iprot.readStructEnd()
14661 
 
14662 
  def write(self, oprot):
14663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14665 
      return
14666 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 14667 
    if self.success is not None:
2536 chandransh 14668 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14669 
      oprot.writeBool(self.success)
14670 
      oprot.writeFieldEnd()
3431 rajveer 14671 
    if self.ex is not None:
2536 chandransh 14672 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14673 
      self.ex.write(oprot)
14674 
      oprot.writeFieldEnd()
14675 
    oprot.writeFieldStop()
14676 
    oprot.writeStructEnd()
14677 
 
3431 rajveer 14678 
  def validate(self):
14679 
    return
14680 
 
14681 
 
2536 chandransh 14682 
  def __repr__(self):
14683 
    L = ['%s=%r' % (key, value)
14684 
      for key, value in self.__dict__.iteritems()]
14685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14686 
 
14687 
  def __eq__(self, other):
14688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14689 
 
14690 
  def __ne__(self, other):
14691 
    return not (self == other)
14692 
 
2764 chandransh 14693 
class markDoasAsPickedUp_args:
14694 
  """
14695 
  Attributes:
14696 
   - providerId
14697 
   - pickupDetails
14698 
  """
14699 
 
14700 
  thrift_spec = (
14701 
    None, # 0
14702 
    (1, TType.I64, 'providerId', None, None, ), # 1
14703 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
14704 
  )
14705 
 
14706 
  def __init__(self, providerId=None, pickupDetails=None,):
14707 
    self.providerId = providerId
14708 
    self.pickupDetails = pickupDetails
14709 
 
14710 
  def read(self, iprot):
14711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14713 
      return
14714 
    iprot.readStructBegin()
14715 
    while True:
14716 
      (fname, ftype, fid) = iprot.readFieldBegin()
14717 
      if ftype == TType.STOP:
14718 
        break
14719 
      if fid == 1:
14720 
        if ftype == TType.I64:
14721 
          self.providerId = iprot.readI64();
14722 
        else:
14723 
          iprot.skip(ftype)
14724 
      elif fid == 2:
14725 
        if ftype == TType.MAP:
14726 
          self.pickupDetails = {}
5031 varun.gupt 14727 
          (_ktype323, _vtype324, _size322 ) = iprot.readMapBegin()
14728 
          for _i326 in xrange(_size322):
14729 
            _key327 = iprot.readString();
14730 
            _val328 = iprot.readString();
14731 
            self.pickupDetails[_key327] = _val328
2764 chandransh 14732 
          iprot.readMapEnd()
14733 
        else:
14734 
          iprot.skip(ftype)
14735 
      else:
14736 
        iprot.skip(ftype)
14737 
      iprot.readFieldEnd()
14738 
    iprot.readStructEnd()
14739 
 
14740 
  def write(self, oprot):
14741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14743 
      return
14744 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 14745 
    if self.providerId is not None:
2764 chandransh 14746 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14747 
      oprot.writeI64(self.providerId)
14748 
      oprot.writeFieldEnd()
3431 rajveer 14749 
    if self.pickupDetails is not None:
2764 chandransh 14750 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14751 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 14752 
      for kiter329,viter330 in self.pickupDetails.items():
14753 
        oprot.writeString(kiter329)
14754 
        oprot.writeString(viter330)
2764 chandransh 14755 
      oprot.writeMapEnd()
14756 
      oprot.writeFieldEnd()
14757 
    oprot.writeFieldStop()
14758 
    oprot.writeStructEnd()
14759 
 
3431 rajveer 14760 
  def validate(self):
14761 
    return
14762 
 
14763 
 
2764 chandransh 14764 
  def __repr__(self):
14765 
    L = ['%s=%r' % (key, value)
14766 
      for key, value in self.__dict__.iteritems()]
14767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14768 
 
14769 
  def __eq__(self, other):
14770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14771 
 
14772 
  def __ne__(self, other):
14773 
    return not (self == other)
14774 
 
14775 
class markDoasAsPickedUp_result:
4910 phani.kuma 14776 
 
14777 
  thrift_spec = (
14778 
  )
14779 
 
14780 
  def read(self, iprot):
14781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14783 
      return
14784 
    iprot.readStructBegin()
14785 
    while True:
14786 
      (fname, ftype, fid) = iprot.readFieldBegin()
14787 
      if ftype == TType.STOP:
14788 
        break
14789 
      else:
14790 
        iprot.skip(ftype)
14791 
      iprot.readFieldEnd()
14792 
    iprot.readStructEnd()
14793 
 
14794 
  def write(self, oprot):
14795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14797 
      return
14798 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
14799 
    oprot.writeFieldStop()
14800 
    oprot.writeStructEnd()
14801 
 
14802 
  def validate(self):
14803 
    return
14804 
 
14805 
 
14806 
  def __repr__(self):
14807 
    L = ['%s=%r' % (key, value)
14808 
      for key, value in self.__dict__.iteritems()]
14809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14810 
 
14811 
  def __eq__(self, other):
14812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14813 
 
14814 
  def __ne__(self, other):
14815 
    return not (self == other)
14816 
 
14817 
class getDoasNotPickedUp_args:
2764 chandransh 14818 
  """
14819 
  Attributes:
4910 phani.kuma 14820 
   - providerId
14821 
  """
14822 
 
14823 
  thrift_spec = (
14824 
    None, # 0
14825 
    (1, TType.I64, 'providerId', None, None, ), # 1
14826 
  )
14827 
 
14828 
  def __init__(self, providerId=None,):
14829 
    self.providerId = providerId
14830 
 
14831 
  def read(self, iprot):
14832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14834 
      return
14835 
    iprot.readStructBegin()
14836 
    while True:
14837 
      (fname, ftype, fid) = iprot.readFieldBegin()
14838 
      if ftype == TType.STOP:
14839 
        break
14840 
      if fid == 1:
14841 
        if ftype == TType.I64:
14842 
          self.providerId = iprot.readI64();
14843 
        else:
14844 
          iprot.skip(ftype)
14845 
      else:
14846 
        iprot.skip(ftype)
14847 
      iprot.readFieldEnd()
14848 
    iprot.readStructEnd()
14849 
 
14850 
  def write(self, oprot):
14851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14853 
      return
14854 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
14855 
    if self.providerId is not None:
14856 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14857 
      oprot.writeI64(self.providerId)
14858 
      oprot.writeFieldEnd()
14859 
    oprot.writeFieldStop()
14860 
    oprot.writeStructEnd()
14861 
 
14862 
  def validate(self):
14863 
    return
14864 
 
14865 
 
14866 
  def __repr__(self):
14867 
    L = ['%s=%r' % (key, value)
14868 
      for key, value in self.__dict__.iteritems()]
14869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14870 
 
14871 
  def __eq__(self, other):
14872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14873 
 
14874 
  def __ne__(self, other):
14875 
    return not (self == other)
14876 
 
14877 
class getDoasNotPickedUp_result:
14878 
  """
14879 
  Attributes:
2764 chandransh 14880 
   - success
14881 
  """
14882 
 
14883 
  thrift_spec = (
14884 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14885 
  )
14886 
 
14887 
  def __init__(self, success=None,):
14888 
    self.success = success
14889 
 
14890 
  def read(self, iprot):
14891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14893 
      return
14894 
    iprot.readStructBegin()
14895 
    while True:
14896 
      (fname, ftype, fid) = iprot.readFieldBegin()
14897 
      if ftype == TType.STOP:
14898 
        break
14899 
      if fid == 0:
14900 
        if ftype == TType.LIST:
14901 
          self.success = []
5031 varun.gupt 14902 
          (_etype334, _size331) = iprot.readListBegin()
14903 
          for _i335 in xrange(_size331):
14904 
            _elem336 = Order()
14905 
            _elem336.read(iprot)
14906 
            self.success.append(_elem336)
2764 chandransh 14907 
          iprot.readListEnd()
14908 
        else:
14909 
          iprot.skip(ftype)
14910 
      else:
14911 
        iprot.skip(ftype)
14912 
      iprot.readFieldEnd()
14913 
    iprot.readStructEnd()
14914 
 
14915 
  def write(self, oprot):
14916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14918 
      return
4910 phani.kuma 14919 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 14920 
    if self.success is not None:
2764 chandransh 14921 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14922 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 14923 
      for iter337 in self.success:
14924 
        iter337.write(oprot)
2764 chandransh 14925 
      oprot.writeListEnd()
14926 
      oprot.writeFieldEnd()
14927 
    oprot.writeFieldStop()
14928 
    oprot.writeStructEnd()
14929 
 
3431 rajveer 14930 
  def validate(self):
14931 
    return
14932 
 
14933 
 
2764 chandransh 14934 
  def __repr__(self):
14935 
    L = ['%s=%r' % (key, value)
14936 
      for key, value in self.__dict__.iteritems()]
14937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14938 
 
14939 
  def __eq__(self, other):
14940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14941 
 
14942 
  def __ne__(self, other):
14943 
    return not (self == other)
14944 
 
4741 phani.kuma 14945 
class markReturnOrdersAsPickedUp_args:
14946 
  """
14947 
  Attributes:
14948 
   - providerId
14949 
   - pickupDetails
14950 
  """
14951 
 
14952 
  thrift_spec = (
14953 
    None, # 0
14954 
    (1, TType.I64, 'providerId', None, None, ), # 1
14955 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
14956 
  )
14957 
 
14958 
  def __init__(self, providerId=None, pickupDetails=None,):
14959 
    self.providerId = providerId
14960 
    self.pickupDetails = pickupDetails
14961 
 
14962 
  def read(self, iprot):
14963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14965 
      return
14966 
    iprot.readStructBegin()
14967 
    while True:
14968 
      (fname, ftype, fid) = iprot.readFieldBegin()
14969 
      if ftype == TType.STOP:
14970 
        break
14971 
      if fid == 1:
14972 
        if ftype == TType.I64:
14973 
          self.providerId = iprot.readI64();
14974 
        else:
14975 
          iprot.skip(ftype)
14976 
      elif fid == 2:
14977 
        if ftype == TType.MAP:
14978 
          self.pickupDetails = {}
5031 varun.gupt 14979 
          (_ktype339, _vtype340, _size338 ) = iprot.readMapBegin()
14980 
          for _i342 in xrange(_size338):
14981 
            _key343 = iprot.readString();
14982 
            _val344 = iprot.readString();
14983 
            self.pickupDetails[_key343] = _val344
4741 phani.kuma 14984 
          iprot.readMapEnd()
14985 
        else:
14986 
          iprot.skip(ftype)
14987 
      else:
14988 
        iprot.skip(ftype)
14989 
      iprot.readFieldEnd()
14990 
    iprot.readStructEnd()
14991 
 
14992 
  def write(self, oprot):
14993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14995 
      return
14996 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
14997 
    if self.providerId is not None:
14998 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14999 
      oprot.writeI64(self.providerId)
15000 
      oprot.writeFieldEnd()
15001 
    if self.pickupDetails is not None:
15002 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15003 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 15004 
      for kiter345,viter346 in self.pickupDetails.items():
15005 
        oprot.writeString(kiter345)
15006 
        oprot.writeString(viter346)
4741 phani.kuma 15007 
      oprot.writeMapEnd()
15008 
      oprot.writeFieldEnd()
15009 
    oprot.writeFieldStop()
15010 
    oprot.writeStructEnd()
15011 
 
15012 
  def validate(self):
15013 
    return
15014 
 
15015 
 
15016 
  def __repr__(self):
15017 
    L = ['%s=%r' % (key, value)
15018 
      for key, value in self.__dict__.iteritems()]
15019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15020 
 
15021 
  def __eq__(self, other):
15022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15023 
 
15024 
  def __ne__(self, other):
15025 
    return not (self == other)
15026 
 
15027 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 15028 
 
15029 
  thrift_spec = (
15030 
  )
15031 
 
15032 
  def read(self, iprot):
15033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15035 
      return
15036 
    iprot.readStructBegin()
15037 
    while True:
15038 
      (fname, ftype, fid) = iprot.readFieldBegin()
15039 
      if ftype == TType.STOP:
15040 
        break
15041 
      else:
15042 
        iprot.skip(ftype)
15043 
      iprot.readFieldEnd()
15044 
    iprot.readStructEnd()
15045 
 
15046 
  def write(self, oprot):
15047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15049 
      return
15050 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
15051 
    oprot.writeFieldStop()
15052 
    oprot.writeStructEnd()
15053 
 
15054 
  def validate(self):
15055 
    return
15056 
 
15057 
 
15058 
  def __repr__(self):
15059 
    L = ['%s=%r' % (key, value)
15060 
      for key, value in self.__dict__.iteritems()]
15061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15062 
 
15063 
  def __eq__(self, other):
15064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15065 
 
15066 
  def __ne__(self, other):
15067 
    return not (self == other)
15068 
 
15069 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 15070 
  """
15071 
  Attributes:
4910 phani.kuma 15072 
   - providerId
15073 
  """
15074 
 
15075 
  thrift_spec = (
15076 
    None, # 0
15077 
    (1, TType.I64, 'providerId', None, None, ), # 1
15078 
  )
15079 
 
15080 
  def __init__(self, providerId=None,):
15081 
    self.providerId = providerId
15082 
 
15083 
  def read(self, iprot):
15084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15086 
      return
15087 
    iprot.readStructBegin()
15088 
    while True:
15089 
      (fname, ftype, fid) = iprot.readFieldBegin()
15090 
      if ftype == TType.STOP:
15091 
        break
15092 
      if fid == 1:
15093 
        if ftype == TType.I64:
15094 
          self.providerId = iprot.readI64();
15095 
        else:
15096 
          iprot.skip(ftype)
15097 
      else:
15098 
        iprot.skip(ftype)
15099 
      iprot.readFieldEnd()
15100 
    iprot.readStructEnd()
15101 
 
15102 
  def write(self, oprot):
15103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15105 
      return
15106 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
15107 
    if self.providerId is not None:
15108 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15109 
      oprot.writeI64(self.providerId)
15110 
      oprot.writeFieldEnd()
15111 
    oprot.writeFieldStop()
15112 
    oprot.writeStructEnd()
15113 
 
15114 
  def validate(self):
15115 
    return
15116 
 
15117 
 
15118 
  def __repr__(self):
15119 
    L = ['%s=%r' % (key, value)
15120 
      for key, value in self.__dict__.iteritems()]
15121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15122 
 
15123 
  def __eq__(self, other):
15124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15125 
 
15126 
  def __ne__(self, other):
15127 
    return not (self == other)
15128 
 
15129 
class getReturnOrdersNotPickedUp_result:
15130 
  """
15131 
  Attributes:
4741 phani.kuma 15132 
   - success
15133 
  """
15134 
 
15135 
  thrift_spec = (
15136 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15137 
  )
15138 
 
15139 
  def __init__(self, success=None,):
15140 
    self.success = success
15141 
 
15142 
  def read(self, iprot):
15143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15145 
      return
15146 
    iprot.readStructBegin()
15147 
    while True:
15148 
      (fname, ftype, fid) = iprot.readFieldBegin()
15149 
      if ftype == TType.STOP:
15150 
        break
15151 
      if fid == 0:
15152 
        if ftype == TType.LIST:
15153 
          self.success = []
5031 varun.gupt 15154 
          (_etype350, _size347) = iprot.readListBegin()
15155 
          for _i351 in xrange(_size347):
15156 
            _elem352 = Order()
15157 
            _elem352.read(iprot)
15158 
            self.success.append(_elem352)
4741 phani.kuma 15159 
          iprot.readListEnd()
15160 
        else:
15161 
          iprot.skip(ftype)
15162 
      else:
15163 
        iprot.skip(ftype)
15164 
      iprot.readFieldEnd()
15165 
    iprot.readStructEnd()
15166 
 
15167 
  def write(self, oprot):
15168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15170 
      return
4910 phani.kuma 15171 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 15172 
    if self.success is not None:
15173 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15174 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 15175 
      for iter353 in self.success:
15176 
        iter353.write(oprot)
4741 phani.kuma 15177 
      oprot.writeListEnd()
15178 
      oprot.writeFieldEnd()
15179 
    oprot.writeFieldStop()
15180 
    oprot.writeStructEnd()
15181 
 
15182 
  def validate(self):
15183 
    return
15184 
 
15185 
 
15186 
  def __repr__(self):
15187 
    L = ['%s=%r' % (key, value)
15188 
      for key, value in self.__dict__.iteritems()]
15189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15190 
 
15191 
  def __eq__(self, other):
15192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15193 
 
15194 
  def __ne__(self, other):
15195 
    return not (self == other)
15196 
 
2616 chandransh 15197 
class receiveReturn_args:
2591 chandransh 15198 
  """
15199 
  Attributes:
15200 
   - orderId
4479 rajveer 15201 
   - receiveCondition
2591 chandransh 15202 
  """
2536 chandransh 15203 
 
2591 chandransh 15204 
  thrift_spec = (
15205 
    None, # 0
15206 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 15207 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 15208 
  )
15209 
 
4479 rajveer 15210 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 15211 
    self.orderId = orderId
4479 rajveer 15212 
    self.receiveCondition = receiveCondition
2591 chandransh 15213 
 
15214 
  def read(self, iprot):
15215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15217 
      return
15218 
    iprot.readStructBegin()
15219 
    while True:
15220 
      (fname, ftype, fid) = iprot.readFieldBegin()
15221 
      if ftype == TType.STOP:
15222 
        break
15223 
      if fid == 1:
15224 
        if ftype == TType.I64:
15225 
          self.orderId = iprot.readI64();
15226 
        else:
15227 
          iprot.skip(ftype)
4479 rajveer 15228 
      elif fid == 2:
15229 
        if ftype == TType.I64:
15230 
          self.receiveCondition = iprot.readI64();
15231 
        else:
15232 
          iprot.skip(ftype)
2591 chandransh 15233 
      else:
15234 
        iprot.skip(ftype)
15235 
      iprot.readFieldEnd()
15236 
    iprot.readStructEnd()
15237 
 
15238 
  def write(self, oprot):
15239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15241 
      return
2616 chandransh 15242 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 15243 
    if self.orderId is not None:
2591 chandransh 15244 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15245 
      oprot.writeI64(self.orderId)
15246 
      oprot.writeFieldEnd()
4479 rajveer 15247 
    if self.receiveCondition is not None:
15248 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
15249 
      oprot.writeI64(self.receiveCondition)
15250 
      oprot.writeFieldEnd()
2591 chandransh 15251 
    oprot.writeFieldStop()
15252 
    oprot.writeStructEnd()
15253 
 
3431 rajveer 15254 
  def validate(self):
15255 
    return
15256 
 
15257 
 
2591 chandransh 15258 
  def __repr__(self):
15259 
    L = ['%s=%r' % (key, value)
15260 
      for key, value in self.__dict__.iteritems()]
15261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15262 
 
15263 
  def __eq__(self, other):
15264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15265 
 
15266 
  def __ne__(self, other):
15267 
    return not (self == other)
15268 
 
2616 chandransh 15269 
class receiveReturn_result:
2591 chandransh 15270 
  """
15271 
  Attributes:
15272 
   - success
15273 
   - ex
15274 
  """
15275 
 
15276 
  thrift_spec = (
15277 
    (0, TType.BOOL, 'success', None, None, ), # 0
15278 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15279 
  )
15280 
 
15281 
  def __init__(self, success=None, ex=None,):
15282 
    self.success = success
15283 
    self.ex = ex
15284 
 
15285 
  def read(self, iprot):
15286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15288 
      return
15289 
    iprot.readStructBegin()
15290 
    while True:
15291 
      (fname, ftype, fid) = iprot.readFieldBegin()
15292 
      if ftype == TType.STOP:
15293 
        break
15294 
      if fid == 0:
15295 
        if ftype == TType.BOOL:
15296 
          self.success = iprot.readBool();
15297 
        else:
15298 
          iprot.skip(ftype)
15299 
      elif fid == 1:
15300 
        if ftype == TType.STRUCT:
15301 
          self.ex = TransactionServiceException()
15302 
          self.ex.read(iprot)
15303 
        else:
15304 
          iprot.skip(ftype)
15305 
      else:
15306 
        iprot.skip(ftype)
15307 
      iprot.readFieldEnd()
15308 
    iprot.readStructEnd()
15309 
 
15310 
  def write(self, oprot):
15311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15313 
      return
2616 chandransh 15314 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 15315 
    if self.success is not None:
2591 chandransh 15316 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15317 
      oprot.writeBool(self.success)
15318 
      oprot.writeFieldEnd()
3431 rajveer 15319 
    if self.ex is not None:
2591 chandransh 15320 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15321 
      self.ex.write(oprot)
15322 
      oprot.writeFieldEnd()
15323 
    oprot.writeFieldStop()
15324 
    oprot.writeStructEnd()
15325 
 
3431 rajveer 15326 
  def validate(self):
15327 
    return
15328 
 
15329 
 
2591 chandransh 15330 
  def __repr__(self):
15331 
    L = ['%s=%r' % (key, value)
15332 
      for key, value in self.__dict__.iteritems()]
15333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15334 
 
15335 
  def __eq__(self, other):
15336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15337 
 
15338 
  def __ne__(self, other):
15339 
    return not (self == other)
15340 
 
15341 
class validateDoa_args:
15342 
  """
15343 
  Attributes:
15344 
   - orderId
15345 
   - isValid
15346 
  """
15347 
 
15348 
  thrift_spec = (
15349 
    None, # 0
15350 
    (1, TType.I64, 'orderId', None, None, ), # 1
15351 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
15352 
  )
15353 
 
15354 
  def __init__(self, orderId=None, isValid=None,):
15355 
    self.orderId = orderId
15356 
    self.isValid = isValid
15357 
 
15358 
  def read(self, iprot):
15359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15361 
      return
15362 
    iprot.readStructBegin()
15363 
    while True:
15364 
      (fname, ftype, fid) = iprot.readFieldBegin()
15365 
      if ftype == TType.STOP:
15366 
        break
15367 
      if fid == 1:
15368 
        if ftype == TType.I64:
15369 
          self.orderId = iprot.readI64();
15370 
        else:
15371 
          iprot.skip(ftype)
15372 
      elif fid == 2:
15373 
        if ftype == TType.BOOL:
15374 
          self.isValid = iprot.readBool();
15375 
        else:
15376 
          iprot.skip(ftype)
15377 
      else:
15378 
        iprot.skip(ftype)
15379 
      iprot.readFieldEnd()
15380 
    iprot.readStructEnd()
15381 
 
15382 
  def write(self, oprot):
15383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15385 
      return
15386 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 15387 
    if self.orderId is not None:
2591 chandransh 15388 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15389 
      oprot.writeI64(self.orderId)
15390 
      oprot.writeFieldEnd()
3431 rajveer 15391 
    if self.isValid is not None:
2591 chandransh 15392 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
15393 
      oprot.writeBool(self.isValid)
15394 
      oprot.writeFieldEnd()
15395 
    oprot.writeFieldStop()
15396 
    oprot.writeStructEnd()
15397 
 
3431 rajveer 15398 
  def validate(self):
15399 
    return
15400 
 
15401 
 
2591 chandransh 15402 
  def __repr__(self):
15403 
    L = ['%s=%r' % (key, value)
15404 
      for key, value in self.__dict__.iteritems()]
15405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15406 
 
15407 
  def __eq__(self, other):
15408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15409 
 
15410 
  def __ne__(self, other):
15411 
    return not (self == other)
15412 
 
15413 
class validateDoa_result:
15414 
  """
15415 
  Attributes:
15416 
   - success
15417 
   - ex
15418 
  """
15419 
 
15420 
  thrift_spec = (
15421 
    (0, TType.BOOL, 'success', None, None, ), # 0
15422 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15423 
  )
15424 
 
15425 
  def __init__(self, success=None, ex=None,):
15426 
    self.success = success
15427 
    self.ex = ex
15428 
 
15429 
  def read(self, iprot):
15430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15432 
      return
15433 
    iprot.readStructBegin()
15434 
    while True:
15435 
      (fname, ftype, fid) = iprot.readFieldBegin()
15436 
      if ftype == TType.STOP:
15437 
        break
15438 
      if fid == 0:
15439 
        if ftype == TType.BOOL:
15440 
          self.success = iprot.readBool();
15441 
        else:
15442 
          iprot.skip(ftype)
15443 
      elif fid == 1:
15444 
        if ftype == TType.STRUCT:
15445 
          self.ex = TransactionServiceException()
15446 
          self.ex.read(iprot)
15447 
        else:
15448 
          iprot.skip(ftype)
15449 
      else:
15450 
        iprot.skip(ftype)
15451 
      iprot.readFieldEnd()
15452 
    iprot.readStructEnd()
15453 
 
15454 
  def write(self, oprot):
15455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15457 
      return
15458 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 15459 
    if self.success is not None:
2591 chandransh 15460 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15461 
      oprot.writeBool(self.success)
15462 
      oprot.writeFieldEnd()
3431 rajveer 15463 
    if self.ex is not None:
2591 chandransh 15464 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15465 
      self.ex.write(oprot)
15466 
      oprot.writeFieldEnd()
15467 
    oprot.writeFieldStop()
15468 
    oprot.writeStructEnd()
15469 
 
3431 rajveer 15470 
  def validate(self):
15471 
    return
15472 
 
15473 
 
2591 chandransh 15474 
  def __repr__(self):
15475 
    L = ['%s=%r' % (key, value)
15476 
      for key, value in self.__dict__.iteritems()]
15477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15478 
 
15479 
  def __eq__(self, other):
15480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15481 
 
15482 
  def __ne__(self, other):
15483 
    return not (self == other)
15484 
 
4495 rajveer 15485 
class validateReturnProduct_args:
15486 
  """
15487 
  Attributes:
15488 
   - orderId
15489 
   - isUsable
15490 
  """
15491 
 
15492 
  thrift_spec = (
15493 
    None, # 0
15494 
    (1, TType.I64, 'orderId', None, None, ), # 1
15495 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
15496 
  )
15497 
 
15498 
  def __init__(self, orderId=None, isUsable=None,):
15499 
    self.orderId = orderId
15500 
    self.isUsable = isUsable
15501 
 
15502 
  def read(self, iprot):
15503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15505 
      return
15506 
    iprot.readStructBegin()
15507 
    while True:
15508 
      (fname, ftype, fid) = iprot.readFieldBegin()
15509 
      if ftype == TType.STOP:
15510 
        break
15511 
      if fid == 1:
15512 
        if ftype == TType.I64:
15513 
          self.orderId = iprot.readI64();
15514 
        else:
15515 
          iprot.skip(ftype)
15516 
      elif fid == 2:
15517 
        if ftype == TType.BOOL:
15518 
          self.isUsable = iprot.readBool();
15519 
        else:
15520 
          iprot.skip(ftype)
15521 
      else:
15522 
        iprot.skip(ftype)
15523 
      iprot.readFieldEnd()
15524 
    iprot.readStructEnd()
15525 
 
15526 
  def write(self, oprot):
15527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15529 
      return
15530 
    oprot.writeStructBegin('validateReturnProduct_args')
15531 
    if self.orderId is not None:
15532 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15533 
      oprot.writeI64(self.orderId)
15534 
      oprot.writeFieldEnd()
15535 
    if self.isUsable is not None:
15536 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
15537 
      oprot.writeBool(self.isUsable)
15538 
      oprot.writeFieldEnd()
15539 
    oprot.writeFieldStop()
15540 
    oprot.writeStructEnd()
15541 
 
15542 
  def validate(self):
15543 
    return
15544 
 
15545 
 
15546 
  def __repr__(self):
15547 
    L = ['%s=%r' % (key, value)
15548 
      for key, value in self.__dict__.iteritems()]
15549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15550 
 
15551 
  def __eq__(self, other):
15552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15553 
 
15554 
  def __ne__(self, other):
15555 
    return not (self == other)
15556 
 
15557 
class validateReturnProduct_result:
15558 
  """
15559 
  Attributes:
15560 
   - success
15561 
   - ex
15562 
  """
15563 
 
15564 
  thrift_spec = (
15565 
    (0, TType.BOOL, 'success', None, None, ), # 0
15566 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15567 
  )
15568 
 
15569 
  def __init__(self, success=None, ex=None,):
15570 
    self.success = success
15571 
    self.ex = ex
15572 
 
15573 
  def read(self, iprot):
15574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15576 
      return
15577 
    iprot.readStructBegin()
15578 
    while True:
15579 
      (fname, ftype, fid) = iprot.readFieldBegin()
15580 
      if ftype == TType.STOP:
15581 
        break
15582 
      if fid == 0:
15583 
        if ftype == TType.BOOL:
15584 
          self.success = iprot.readBool();
15585 
        else:
15586 
          iprot.skip(ftype)
15587 
      elif fid == 1:
15588 
        if ftype == TType.STRUCT:
15589 
          self.ex = TransactionServiceException()
15590 
          self.ex.read(iprot)
15591 
        else:
15592 
          iprot.skip(ftype)
15593 
      else:
15594 
        iprot.skip(ftype)
15595 
      iprot.readFieldEnd()
15596 
    iprot.readStructEnd()
15597 
 
15598 
  def write(self, oprot):
15599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15601 
      return
15602 
    oprot.writeStructBegin('validateReturnProduct_result')
15603 
    if self.success is not None:
15604 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15605 
      oprot.writeBool(self.success)
15606 
      oprot.writeFieldEnd()
15607 
    if self.ex is not None:
15608 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15609 
      self.ex.write(oprot)
15610 
      oprot.writeFieldEnd()
15611 
    oprot.writeFieldStop()
15612 
    oprot.writeStructEnd()
15613 
 
15614 
  def validate(self):
15615 
    return
15616 
 
15617 
 
15618 
  def __repr__(self):
15619 
    L = ['%s=%r' % (key, value)
15620 
      for key, value in self.__dict__.iteritems()]
15621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15622 
 
15623 
  def __eq__(self, other):
15624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15625 
 
15626 
  def __ne__(self, other):
15627 
    return not (self == other)
15628 
 
2616 chandransh 15629 
class reshipOrder_args:
15630 
  """
15631 
  Attributes:
15632 
   - orderId
15633 
  """
2591 chandransh 15634 
 
2616 chandransh 15635 
  thrift_spec = (
15636 
    None, # 0
15637 
    (1, TType.I64, 'orderId', None, None, ), # 1
15638 
  )
15639 
 
15640 
  def __init__(self, orderId=None,):
15641 
    self.orderId = orderId
15642 
 
15643 
  def read(self, iprot):
15644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15646 
      return
15647 
    iprot.readStructBegin()
15648 
    while True:
15649 
      (fname, ftype, fid) = iprot.readFieldBegin()
15650 
      if ftype == TType.STOP:
15651 
        break
15652 
      if fid == 1:
15653 
        if ftype == TType.I64:
15654 
          self.orderId = iprot.readI64();
15655 
        else:
15656 
          iprot.skip(ftype)
15657 
      else:
15658 
        iprot.skip(ftype)
15659 
      iprot.readFieldEnd()
15660 
    iprot.readStructEnd()
15661 
 
15662 
  def write(self, oprot):
15663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15665 
      return
15666 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 15667 
    if self.orderId is not None:
2616 chandransh 15668 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15669 
      oprot.writeI64(self.orderId)
15670 
      oprot.writeFieldEnd()
15671 
    oprot.writeFieldStop()
15672 
    oprot.writeStructEnd()
15673 
 
3431 rajveer 15674 
  def validate(self):
15675 
    return
15676 
 
15677 
 
2616 chandransh 15678 
  def __repr__(self):
15679 
    L = ['%s=%r' % (key, value)
15680 
      for key, value in self.__dict__.iteritems()]
15681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15682 
 
15683 
  def __eq__(self, other):
15684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15685 
 
15686 
  def __ne__(self, other):
15687 
    return not (self == other)
15688 
 
15689 
class reshipOrder_result:
15690 
  """
15691 
  Attributes:
15692 
   - success
15693 
   - ex
15694 
  """
15695 
 
15696 
  thrift_spec = (
15697 
    (0, TType.I64, 'success', None, None, ), # 0
15698 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15699 
  )
15700 
 
15701 
  def __init__(self, success=None, ex=None,):
15702 
    self.success = success
15703 
    self.ex = ex
15704 
 
15705 
  def read(self, iprot):
15706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15708 
      return
15709 
    iprot.readStructBegin()
15710 
    while True:
15711 
      (fname, ftype, fid) = iprot.readFieldBegin()
15712 
      if ftype == TType.STOP:
15713 
        break
15714 
      if fid == 0:
15715 
        if ftype == TType.I64:
15716 
          self.success = iprot.readI64();
15717 
        else:
15718 
          iprot.skip(ftype)
15719 
      elif fid == 1:
15720 
        if ftype == TType.STRUCT:
15721 
          self.ex = TransactionServiceException()
15722 
          self.ex.read(iprot)
15723 
        else:
15724 
          iprot.skip(ftype)
15725 
      else:
15726 
        iprot.skip(ftype)
15727 
      iprot.readFieldEnd()
15728 
    iprot.readStructEnd()
15729 
 
15730 
  def write(self, oprot):
15731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15733 
      return
15734 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 15735 
    if self.success is not None:
2616 chandransh 15736 
      oprot.writeFieldBegin('success', TType.I64, 0)
15737 
      oprot.writeI64(self.success)
15738 
      oprot.writeFieldEnd()
3431 rajveer 15739 
    if self.ex is not None:
2616 chandransh 15740 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15741 
      self.ex.write(oprot)
15742 
      oprot.writeFieldEnd()
15743 
    oprot.writeFieldStop()
15744 
    oprot.writeStructEnd()
15745 
 
3431 rajveer 15746 
  def validate(self):
15747 
    return
15748 
 
15749 
 
2616 chandransh 15750 
  def __repr__(self):
15751 
    L = ['%s=%r' % (key, value)
15752 
      for key, value in self.__dict__.iteritems()]
15753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15754 
 
15755 
  def __eq__(self, other):
15756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15757 
 
15758 
  def __ne__(self, other):
15759 
    return not (self == other)
15760 
 
15761 
class refundOrder_args:
15762 
  """
15763 
  Attributes:
15764 
   - orderId
3226 chandransh 15765 
   - refundedBy
15766 
   - reason
2616 chandransh 15767 
  """
15768 
 
15769 
  thrift_spec = (
15770 
    None, # 0
15771 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 15772 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
15773 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 15774 
  )
15775 
 
3226 chandransh 15776 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 15777 
    self.orderId = orderId
3226 chandransh 15778 
    self.refundedBy = refundedBy
15779 
    self.reason = reason
2616 chandransh 15780 
 
15781 
  def read(self, iprot):
15782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15784 
      return
15785 
    iprot.readStructBegin()
15786 
    while True:
15787 
      (fname, ftype, fid) = iprot.readFieldBegin()
15788 
      if ftype == TType.STOP:
15789 
        break
15790 
      if fid == 1:
15791 
        if ftype == TType.I64:
15792 
          self.orderId = iprot.readI64();
15793 
        else:
15794 
          iprot.skip(ftype)
3226 chandransh 15795 
      elif fid == 2:
15796 
        if ftype == TType.STRING:
15797 
          self.refundedBy = iprot.readString();
15798 
        else:
15799 
          iprot.skip(ftype)
15800 
      elif fid == 3:
15801 
        if ftype == TType.STRING:
15802 
          self.reason = iprot.readString();
15803 
        else:
15804 
          iprot.skip(ftype)
2616 chandransh 15805 
      else:
15806 
        iprot.skip(ftype)
15807 
      iprot.readFieldEnd()
15808 
    iprot.readStructEnd()
15809 
 
15810 
  def write(self, oprot):
15811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15813 
      return
15814 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 15815 
    if self.orderId is not None:
2616 chandransh 15816 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15817 
      oprot.writeI64(self.orderId)
15818 
      oprot.writeFieldEnd()
3431 rajveer 15819 
    if self.refundedBy is not None:
3226 chandransh 15820 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
15821 
      oprot.writeString(self.refundedBy)
15822 
      oprot.writeFieldEnd()
3431 rajveer 15823 
    if self.reason is not None:
3226 chandransh 15824 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
15825 
      oprot.writeString(self.reason)
15826 
      oprot.writeFieldEnd()
2616 chandransh 15827 
    oprot.writeFieldStop()
15828 
    oprot.writeStructEnd()
15829 
 
3431 rajveer 15830 
  def validate(self):
15831 
    return
15832 
 
15833 
 
2616 chandransh 15834 
  def __repr__(self):
15835 
    L = ['%s=%r' % (key, value)
15836 
      for key, value in self.__dict__.iteritems()]
15837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15838 
 
15839 
  def __eq__(self, other):
15840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15841 
 
15842 
  def __ne__(self, other):
15843 
    return not (self == other)
15844 
 
15845 
class refundOrder_result:
15846 
  """
15847 
  Attributes:
15848 
   - success
15849 
   - ex
15850 
  """
15851 
 
15852 
  thrift_spec = (
15853 
    (0, TType.BOOL, 'success', None, None, ), # 0
15854 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15855 
  )
15856 
 
15857 
  def __init__(self, success=None, ex=None,):
15858 
    self.success = success
15859 
    self.ex = ex
15860 
 
15861 
  def read(self, iprot):
15862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15864 
      return
15865 
    iprot.readStructBegin()
15866 
    while True:
15867 
      (fname, ftype, fid) = iprot.readFieldBegin()
15868 
      if ftype == TType.STOP:
15869 
        break
15870 
      if fid == 0:
15871 
        if ftype == TType.BOOL:
15872 
          self.success = iprot.readBool();
15873 
        else:
15874 
          iprot.skip(ftype)
15875 
      elif fid == 1:
15876 
        if ftype == TType.STRUCT:
15877 
          self.ex = TransactionServiceException()
15878 
          self.ex.read(iprot)
15879 
        else:
15880 
          iprot.skip(ftype)
15881 
      else:
15882 
        iprot.skip(ftype)
15883 
      iprot.readFieldEnd()
15884 
    iprot.readStructEnd()
15885 
 
15886 
  def write(self, oprot):
15887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15889 
      return
15890 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 15891 
    if self.success is not None:
2616 chandransh 15892 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15893 
      oprot.writeBool(self.success)
15894 
      oprot.writeFieldEnd()
3431 rajveer 15895 
    if self.ex is not None:
2616 chandransh 15896 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15897 
      self.ex.write(oprot)
15898 
      oprot.writeFieldEnd()
15899 
    oprot.writeFieldStop()
15900 
    oprot.writeStructEnd()
15901 
 
3431 rajveer 15902 
  def validate(self):
15903 
    return
15904 
 
15905 
 
2616 chandransh 15906 
  def __repr__(self):
15907 
    L = ['%s=%r' % (key, value)
15908 
      for key, value in self.__dict__.iteritems()]
15909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15910 
 
15911 
  def __eq__(self, other):
15912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15913 
 
15914 
  def __ne__(self, other):
15915 
    return not (self == other)
15916 
 
2690 chandransh 15917 
class getReturnOrders_args:
15918 
  """
15919 
  Attributes:
15920 
   - warehouseId
15921 
   - fromDate
15922 
   - toDate
15923 
  """
2616 chandransh 15924 
 
2690 chandransh 15925 
  thrift_spec = (
15926 
    None, # 0
15927 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
15928 
    (2, TType.I64, 'fromDate', None, None, ), # 2
15929 
    (3, TType.I64, 'toDate', None, None, ), # 3
15930 
  )
15931 
 
15932 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
15933 
    self.warehouseId = warehouseId
15934 
    self.fromDate = fromDate
15935 
    self.toDate = toDate
15936 
 
15937 
  def read(self, iprot):
15938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15940 
      return
15941 
    iprot.readStructBegin()
15942 
    while True:
15943 
      (fname, ftype, fid) = iprot.readFieldBegin()
15944 
      if ftype == TType.STOP:
15945 
        break
15946 
      if fid == 1:
15947 
        if ftype == TType.I64:
15948 
          self.warehouseId = iprot.readI64();
15949 
        else:
15950 
          iprot.skip(ftype)
15951 
      elif fid == 2:
15952 
        if ftype == TType.I64:
15953 
          self.fromDate = iprot.readI64();
15954 
        else:
15955 
          iprot.skip(ftype)
15956 
      elif fid == 3:
15957 
        if ftype == TType.I64:
15958 
          self.toDate = iprot.readI64();
15959 
        else:
15960 
          iprot.skip(ftype)
15961 
      else:
15962 
        iprot.skip(ftype)
15963 
      iprot.readFieldEnd()
15964 
    iprot.readStructEnd()
15965 
 
15966 
  def write(self, oprot):
15967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15969 
      return
15970 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 15971 
    if self.warehouseId is not None:
2690 chandransh 15972 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
15973 
      oprot.writeI64(self.warehouseId)
15974 
      oprot.writeFieldEnd()
3431 rajveer 15975 
    if self.fromDate is not None:
2690 chandransh 15976 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
15977 
      oprot.writeI64(self.fromDate)
15978 
      oprot.writeFieldEnd()
3431 rajveer 15979 
    if self.toDate is not None:
2690 chandransh 15980 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
15981 
      oprot.writeI64(self.toDate)
15982 
      oprot.writeFieldEnd()
15983 
    oprot.writeFieldStop()
15984 
    oprot.writeStructEnd()
15985 
 
3431 rajveer 15986 
  def validate(self):
15987 
    return
15988 
 
15989 
 
2690 chandransh 15990 
  def __repr__(self):
15991 
    L = ['%s=%r' % (key, value)
15992 
      for key, value in self.__dict__.iteritems()]
15993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15994 
 
15995 
  def __eq__(self, other):
15996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15997 
 
15998 
  def __ne__(self, other):
15999 
    return not (self == other)
16000 
 
16001 
class getReturnOrders_result:
16002 
  """
16003 
  Attributes:
16004 
   - success
16005 
  """
16006 
 
16007 
  thrift_spec = (
16008 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
16009 
  )
16010 
 
16011 
  def __init__(self, success=None,):
16012 
    self.success = success
16013 
 
16014 
  def read(self, iprot):
16015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16017 
      return
16018 
    iprot.readStructBegin()
16019 
    while True:
16020 
      (fname, ftype, fid) = iprot.readFieldBegin()
16021 
      if ftype == TType.STOP:
16022 
        break
16023 
      if fid == 0:
16024 
        if ftype == TType.LIST:
16025 
          self.success = []
5031 varun.gupt 16026 
          (_etype357, _size354) = iprot.readListBegin()
16027 
          for _i358 in xrange(_size354):
16028 
            _elem359 = ReturnOrder()
16029 
            _elem359.read(iprot)
16030 
            self.success.append(_elem359)
2690 chandransh 16031 
          iprot.readListEnd()
16032 
        else:
16033 
          iprot.skip(ftype)
16034 
      else:
16035 
        iprot.skip(ftype)
16036 
      iprot.readFieldEnd()
16037 
    iprot.readStructEnd()
16038 
 
16039 
  def write(self, oprot):
16040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16042 
      return
16043 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 16044 
    if self.success is not None:
2690 chandransh 16045 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16046 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 16047 
      for iter360 in self.success:
16048 
        iter360.write(oprot)
2690 chandransh 16049 
      oprot.writeListEnd()
16050 
      oprot.writeFieldEnd()
16051 
    oprot.writeFieldStop()
16052 
    oprot.writeStructEnd()
16053 
 
3431 rajveer 16054 
  def validate(self):
16055 
    return
16056 
 
16057 
 
2690 chandransh 16058 
  def __repr__(self):
16059 
    L = ['%s=%r' % (key, value)
16060 
      for key, value in self.__dict__.iteritems()]
16061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16062 
 
16063 
  def __eq__(self, other):
16064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16065 
 
16066 
  def __ne__(self, other):
16067 
    return not (self == other)
16068 
 
2700 chandransh 16069 
class getReturnOrder_args:
16070 
  """
16071 
  Attributes:
16072 
   - id
16073 
  """
16074 
 
16075 
  thrift_spec = (
16076 
    None, # 0
16077 
    (1, TType.I64, 'id', None, None, ), # 1
16078 
  )
16079 
 
16080 
  def __init__(self, id=None,):
16081 
    self.id = id
16082 
 
16083 
  def read(self, iprot):
16084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16086 
      return
16087 
    iprot.readStructBegin()
16088 
    while True:
16089 
      (fname, ftype, fid) = iprot.readFieldBegin()
16090 
      if ftype == TType.STOP:
16091 
        break
16092 
      if fid == 1:
16093 
        if ftype == TType.I64:
16094 
          self.id = iprot.readI64();
16095 
        else:
16096 
          iprot.skip(ftype)
16097 
      else:
16098 
        iprot.skip(ftype)
16099 
      iprot.readFieldEnd()
16100 
    iprot.readStructEnd()
16101 
 
16102 
  def write(self, oprot):
16103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16105 
      return
16106 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 16107 
    if self.id is not None:
2700 chandransh 16108 
      oprot.writeFieldBegin('id', TType.I64, 1)
16109 
      oprot.writeI64(self.id)
16110 
      oprot.writeFieldEnd()
16111 
    oprot.writeFieldStop()
16112 
    oprot.writeStructEnd()
16113 
 
3431 rajveer 16114 
  def validate(self):
16115 
    return
16116 
 
16117 
 
2700 chandransh 16118 
  def __repr__(self):
16119 
    L = ['%s=%r' % (key, value)
16120 
      for key, value in self.__dict__.iteritems()]
16121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16122 
 
16123 
  def __eq__(self, other):
16124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16125 
 
16126 
  def __ne__(self, other):
16127 
    return not (self == other)
16128 
 
16129 
class getReturnOrder_result:
16130 
  """
16131 
  Attributes:
16132 
   - success
16133 
   - ex
16134 
  """
16135 
 
16136 
  thrift_spec = (
16137 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
16138 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16139 
  )
16140 
 
16141 
  def __init__(self, success=None, ex=None,):
16142 
    self.success = success
16143 
    self.ex = ex
16144 
 
16145 
  def read(self, iprot):
16146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16148 
      return
16149 
    iprot.readStructBegin()
16150 
    while True:
16151 
      (fname, ftype, fid) = iprot.readFieldBegin()
16152 
      if ftype == TType.STOP:
16153 
        break
16154 
      if fid == 0:
16155 
        if ftype == TType.STRUCT:
16156 
          self.success = ReturnOrder()
16157 
          self.success.read(iprot)
16158 
        else:
16159 
          iprot.skip(ftype)
16160 
      elif fid == 1:
16161 
        if ftype == TType.STRUCT:
16162 
          self.ex = TransactionServiceException()
16163 
          self.ex.read(iprot)
16164 
        else:
16165 
          iprot.skip(ftype)
16166 
      else:
16167 
        iprot.skip(ftype)
16168 
      iprot.readFieldEnd()
16169 
    iprot.readStructEnd()
16170 
 
16171 
  def write(self, oprot):
16172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16174 
      return
16175 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 16176 
    if self.success is not None:
2700 chandransh 16177 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16178 
      self.success.write(oprot)
16179 
      oprot.writeFieldEnd()
3431 rajveer 16180 
    if self.ex is not None:
2700 chandransh 16181 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16182 
      self.ex.write(oprot)
16183 
      oprot.writeFieldEnd()
16184 
    oprot.writeFieldStop()
16185 
    oprot.writeStructEnd()
16186 
 
3431 rajveer 16187 
  def validate(self):
16188 
    return
16189 
 
16190 
 
2700 chandransh 16191 
  def __repr__(self):
16192 
    L = ['%s=%r' % (key, value)
16193 
      for key, value in self.__dict__.iteritems()]
16194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16195 
 
16196 
  def __eq__(self, other):
16197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16198 
 
16199 
  def __ne__(self, other):
16200 
    return not (self == other)
16201 
 
2690 chandransh 16202 
class processReturn_args:
16203 
  """
16204 
  Attributes:
16205 
   - returnOrderId
16206 
  """
16207 
 
16208 
  thrift_spec = (
16209 
    None, # 0
16210 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
16211 
  )
16212 
 
16213 
  def __init__(self, returnOrderId=None,):
16214 
    self.returnOrderId = returnOrderId
16215 
 
16216 
  def read(self, iprot):
16217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16219 
      return
16220 
    iprot.readStructBegin()
16221 
    while True:
16222 
      (fname, ftype, fid) = iprot.readFieldBegin()
16223 
      if ftype == TType.STOP:
16224 
        break
16225 
      if fid == 1:
16226 
        if ftype == TType.I64:
16227 
          self.returnOrderId = iprot.readI64();
16228 
        else:
16229 
          iprot.skip(ftype)
16230 
      else:
16231 
        iprot.skip(ftype)
16232 
      iprot.readFieldEnd()
16233 
    iprot.readStructEnd()
16234 
 
16235 
  def write(self, oprot):
16236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16238 
      return
16239 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 16240 
    if self.returnOrderId is not None:
2690 chandransh 16241 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
16242 
      oprot.writeI64(self.returnOrderId)
16243 
      oprot.writeFieldEnd()
16244 
    oprot.writeFieldStop()
16245 
    oprot.writeStructEnd()
16246 
 
3431 rajveer 16247 
  def validate(self):
16248 
    return
16249 
 
16250 
 
2690 chandransh 16251 
  def __repr__(self):
16252 
    L = ['%s=%r' % (key, value)
16253 
      for key, value in self.__dict__.iteritems()]
16254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16255 
 
16256 
  def __eq__(self, other):
16257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16258 
 
16259 
  def __ne__(self, other):
16260 
    return not (self == other)
16261 
 
16262 
class processReturn_result:
16263 
  """
16264 
  Attributes:
16265 
   - ex
16266 
  """
16267 
 
16268 
  thrift_spec = (
16269 
    None, # 0
16270 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16271 
  )
16272 
 
16273 
  def __init__(self, ex=None,):
16274 
    self.ex = ex
16275 
 
16276 
  def read(self, iprot):
16277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16279 
      return
16280 
    iprot.readStructBegin()
16281 
    while True:
16282 
      (fname, ftype, fid) = iprot.readFieldBegin()
16283 
      if ftype == TType.STOP:
16284 
        break
16285 
      if fid == 1:
16286 
        if ftype == TType.STRUCT:
16287 
          self.ex = TransactionServiceException()
16288 
          self.ex.read(iprot)
16289 
        else:
16290 
          iprot.skip(ftype)
16291 
      else:
16292 
        iprot.skip(ftype)
16293 
      iprot.readFieldEnd()
16294 
    iprot.readStructEnd()
16295 
 
16296 
  def write(self, oprot):
16297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16299 
      return
16300 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 16301 
    if self.ex is not None:
2690 chandransh 16302 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16303 
      self.ex.write(oprot)
16304 
      oprot.writeFieldEnd()
16305 
    oprot.writeFieldStop()
16306 
    oprot.writeStructEnd()
16307 
 
3431 rajveer 16308 
  def validate(self):
16309 
    return
16310 
 
16311 
 
2690 chandransh 16312 
  def __repr__(self):
16313 
    L = ['%s=%r' % (key, value)
16314 
      for key, value in self.__dict__.iteritems()]
16315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16316 
 
16317 
  def __eq__(self, other):
16318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16319 
 
16320 
  def __ne__(self, other):
16321 
    return not (self == other)
16322 
 
3451 chandransh 16323 
class updateWeight_args:
16324 
  """
16325 
  Attributes:
16326 
   - orderId
16327 
   - weight
16328 
  """
16329 
 
16330 
  thrift_spec = (
16331 
    None, # 0
16332 
    (1, TType.I64, 'orderId', None, None, ), # 1
16333 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
16334 
  )
16335 
 
16336 
  def __init__(self, orderId=None, weight=None,):
16337 
    self.orderId = orderId
16338 
    self.weight = weight
16339 
 
16340 
  def read(self, iprot):
16341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16343 
      return
16344 
    iprot.readStructBegin()
16345 
    while True:
16346 
      (fname, ftype, fid) = iprot.readFieldBegin()
16347 
      if ftype == TType.STOP:
16348 
        break
16349 
      if fid == 1:
16350 
        if ftype == TType.I64:
16351 
          self.orderId = iprot.readI64();
16352 
        else:
16353 
          iprot.skip(ftype)
16354 
      elif fid == 2:
16355 
        if ftype == TType.DOUBLE:
16356 
          self.weight = iprot.readDouble();
16357 
        else:
16358 
          iprot.skip(ftype)
16359 
      else:
16360 
        iprot.skip(ftype)
16361 
      iprot.readFieldEnd()
16362 
    iprot.readStructEnd()
16363 
 
16364 
  def write(self, oprot):
16365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16367 
      return
16368 
    oprot.writeStructBegin('updateWeight_args')
16369 
    if self.orderId is not None:
16370 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16371 
      oprot.writeI64(self.orderId)
16372 
      oprot.writeFieldEnd()
16373 
    if self.weight is not None:
16374 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
16375 
      oprot.writeDouble(self.weight)
16376 
      oprot.writeFieldEnd()
16377 
    oprot.writeFieldStop()
16378 
    oprot.writeStructEnd()
16379 
 
16380 
  def validate(self):
16381 
    return
16382 
 
16383 
 
16384 
  def __repr__(self):
16385 
    L = ['%s=%r' % (key, value)
16386 
      for key, value in self.__dict__.iteritems()]
16387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16388 
 
16389 
  def __eq__(self, other):
16390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16391 
 
16392 
  def __ne__(self, other):
16393 
    return not (self == other)
16394 
 
16395 
class updateWeight_result:
16396 
  """
16397 
  Attributes:
16398 
   - success
16399 
   - ex
16400 
  """
16401 
 
16402 
  thrift_spec = (
16403 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16404 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16405 
  )
16406 
 
16407 
  def __init__(self, success=None, ex=None,):
16408 
    self.success = success
16409 
    self.ex = ex
16410 
 
16411 
  def read(self, iprot):
16412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16414 
      return
16415 
    iprot.readStructBegin()
16416 
    while True:
16417 
      (fname, ftype, fid) = iprot.readFieldBegin()
16418 
      if ftype == TType.STOP:
16419 
        break
16420 
      if fid == 0:
16421 
        if ftype == TType.STRUCT:
16422 
          self.success = Order()
16423 
          self.success.read(iprot)
16424 
        else:
16425 
          iprot.skip(ftype)
16426 
      elif fid == 1:
16427 
        if ftype == TType.STRUCT:
16428 
          self.ex = TransactionServiceException()
16429 
          self.ex.read(iprot)
16430 
        else:
16431 
          iprot.skip(ftype)
16432 
      else:
16433 
        iprot.skip(ftype)
16434 
      iprot.readFieldEnd()
16435 
    iprot.readStructEnd()
16436 
 
16437 
  def write(self, oprot):
16438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16440 
      return
16441 
    oprot.writeStructBegin('updateWeight_result')
16442 
    if self.success is not None:
16443 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16444 
      self.success.write(oprot)
16445 
      oprot.writeFieldEnd()
16446 
    if self.ex is not None:
16447 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16448 
      self.ex.write(oprot)
16449 
      oprot.writeFieldEnd()
16450 
    oprot.writeFieldStop()
16451 
    oprot.writeStructEnd()
16452 
 
16453 
  def validate(self):
16454 
    return
16455 
 
16456 
 
16457 
  def __repr__(self):
16458 
    L = ['%s=%r' % (key, value)
16459 
      for key, value in self.__dict__.iteritems()]
16460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16461 
 
16462 
  def __eq__(self, other):
16463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16464 
 
16465 
  def __ne__(self, other):
16466 
    return not (self == other)
3469 chandransh 16467 
 
16468 
class changeItem_args:
16469 
  """
16470 
  Attributes:
16471 
   - orderId
16472 
   - itemId
16473 
  """
16474 
 
16475 
  thrift_spec = (
16476 
    None, # 0
16477 
    (1, TType.I64, 'orderId', None, None, ), # 1
16478 
    (2, TType.I64, 'itemId', None, None, ), # 2
16479 
  )
16480 
 
16481 
  def __init__(self, orderId=None, itemId=None,):
16482 
    self.orderId = orderId
16483 
    self.itemId = itemId
16484 
 
16485 
  def read(self, iprot):
16486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16488 
      return
16489 
    iprot.readStructBegin()
16490 
    while True:
16491 
      (fname, ftype, fid) = iprot.readFieldBegin()
16492 
      if ftype == TType.STOP:
16493 
        break
16494 
      if fid == 1:
16495 
        if ftype == TType.I64:
16496 
          self.orderId = iprot.readI64();
16497 
        else:
16498 
          iprot.skip(ftype)
16499 
      elif fid == 2:
16500 
        if ftype == TType.I64:
16501 
          self.itemId = iprot.readI64();
16502 
        else:
16503 
          iprot.skip(ftype)
16504 
      else:
16505 
        iprot.skip(ftype)
16506 
      iprot.readFieldEnd()
16507 
    iprot.readStructEnd()
16508 
 
16509 
  def write(self, oprot):
16510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16512 
      return
16513 
    oprot.writeStructBegin('changeItem_args')
16514 
    if self.orderId is not None:
16515 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16516 
      oprot.writeI64(self.orderId)
16517 
      oprot.writeFieldEnd()
16518 
    if self.itemId is not None:
16519 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16520 
      oprot.writeI64(self.itemId)
16521 
      oprot.writeFieldEnd()
16522 
    oprot.writeFieldStop()
16523 
    oprot.writeStructEnd()
16524 
 
16525 
  def validate(self):
16526 
    return
16527 
 
16528 
 
16529 
  def __repr__(self):
16530 
    L = ['%s=%r' % (key, value)
16531 
      for key, value in self.__dict__.iteritems()]
16532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16533 
 
16534 
  def __eq__(self, other):
16535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16536 
 
16537 
  def __ne__(self, other):
16538 
    return not (self == other)
16539 
 
16540 
class changeItem_result:
16541 
  """
16542 
  Attributes:
16543 
   - success
16544 
   - ex
16545 
  """
16546 
 
16547 
  thrift_spec = (
16548 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16549 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16550 
  )
16551 
 
16552 
  def __init__(self, success=None, ex=None,):
16553 
    self.success = success
16554 
    self.ex = ex
16555 
 
16556 
  def read(self, iprot):
16557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16559 
      return
16560 
    iprot.readStructBegin()
16561 
    while True:
16562 
      (fname, ftype, fid) = iprot.readFieldBegin()
16563 
      if ftype == TType.STOP:
16564 
        break
16565 
      if fid == 0:
16566 
        if ftype == TType.STRUCT:
16567 
          self.success = Order()
16568 
          self.success.read(iprot)
16569 
        else:
16570 
          iprot.skip(ftype)
16571 
      elif fid == 1:
16572 
        if ftype == TType.STRUCT:
16573 
          self.ex = TransactionServiceException()
16574 
          self.ex.read(iprot)
16575 
        else:
16576 
          iprot.skip(ftype)
16577 
      else:
16578 
        iprot.skip(ftype)
16579 
      iprot.readFieldEnd()
16580 
    iprot.readStructEnd()
16581 
 
16582 
  def write(self, oprot):
16583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16585 
      return
16586 
    oprot.writeStructBegin('changeItem_result')
16587 
    if self.success is not None:
16588 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16589 
      self.success.write(oprot)
16590 
      oprot.writeFieldEnd()
16591 
    if self.ex is not None:
16592 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16593 
      self.ex.write(oprot)
16594 
      oprot.writeFieldEnd()
16595 
    oprot.writeFieldStop()
16596 
    oprot.writeStructEnd()
16597 
 
16598 
  def validate(self):
16599 
    return
16600 
 
16601 
 
16602 
  def __repr__(self):
16603 
    L = ['%s=%r' % (key, value)
16604 
      for key, value in self.__dict__.iteritems()]
16605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16606 
 
16607 
  def __eq__(self, other):
16608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16609 
 
16610 
  def __ne__(self, other):
16611 
    return not (self == other)
16612 
 
16613 
class shiftToWarehouse_args:
16614 
  """
16615 
  Attributes:
16616 
   - orderId
16617 
   - warehouseId
16618 
  """
16619 
 
16620 
  thrift_spec = (
16621 
    None, # 0
16622 
    (1, TType.I64, 'orderId', None, None, ), # 1
16623 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
16624 
  )
16625 
 
16626 
  def __init__(self, orderId=None, warehouseId=None,):
16627 
    self.orderId = orderId
16628 
    self.warehouseId = warehouseId
16629 
 
16630 
  def read(self, iprot):
16631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16633 
      return
16634 
    iprot.readStructBegin()
16635 
    while True:
16636 
      (fname, ftype, fid) = iprot.readFieldBegin()
16637 
      if ftype == TType.STOP:
16638 
        break
16639 
      if fid == 1:
16640 
        if ftype == TType.I64:
16641 
          self.orderId = iprot.readI64();
16642 
        else:
16643 
          iprot.skip(ftype)
16644 
      elif fid == 2:
16645 
        if ftype == TType.I64:
16646 
          self.warehouseId = iprot.readI64();
16647 
        else:
16648 
          iprot.skip(ftype)
16649 
      else:
16650 
        iprot.skip(ftype)
16651 
      iprot.readFieldEnd()
16652 
    iprot.readStructEnd()
16653 
 
16654 
  def write(self, oprot):
16655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16657 
      return
16658 
    oprot.writeStructBegin('shiftToWarehouse_args')
16659 
    if self.orderId is not None:
16660 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16661 
      oprot.writeI64(self.orderId)
16662 
      oprot.writeFieldEnd()
16663 
    if self.warehouseId is not None:
16664 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16665 
      oprot.writeI64(self.warehouseId)
16666 
      oprot.writeFieldEnd()
16667 
    oprot.writeFieldStop()
16668 
    oprot.writeStructEnd()
16669 
 
16670 
  def validate(self):
16671 
    return
16672 
 
16673 
 
16674 
  def __repr__(self):
16675 
    L = ['%s=%r' % (key, value)
16676 
      for key, value in self.__dict__.iteritems()]
16677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16678 
 
16679 
  def __eq__(self, other):
16680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16681 
 
16682 
  def __ne__(self, other):
16683 
    return not (self == other)
16684 
 
16685 
class shiftToWarehouse_result:
16686 
  """
16687 
  Attributes:
16688 
   - success
16689 
   - ex
16690 
  """
16691 
 
16692 
  thrift_spec = (
16693 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16694 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16695 
  )
16696 
 
16697 
  def __init__(self, success=None, ex=None,):
16698 
    self.success = success
16699 
    self.ex = ex
16700 
 
16701 
  def read(self, iprot):
16702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16704 
      return
16705 
    iprot.readStructBegin()
16706 
    while True:
16707 
      (fname, ftype, fid) = iprot.readFieldBegin()
16708 
      if ftype == TType.STOP:
16709 
        break
16710 
      if fid == 0:
16711 
        if ftype == TType.STRUCT:
16712 
          self.success = Order()
16713 
          self.success.read(iprot)
16714 
        else:
16715 
          iprot.skip(ftype)
16716 
      elif fid == 1:
16717 
        if ftype == TType.STRUCT:
16718 
          self.ex = TransactionServiceException()
16719 
          self.ex.read(iprot)
16720 
        else:
16721 
          iprot.skip(ftype)
16722 
      else:
16723 
        iprot.skip(ftype)
16724 
      iprot.readFieldEnd()
16725 
    iprot.readStructEnd()
16726 
 
16727 
  def write(self, oprot):
16728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16730 
      return
16731 
    oprot.writeStructBegin('shiftToWarehouse_result')
16732 
    if self.success is not None:
16733 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16734 
      self.success.write(oprot)
16735 
      oprot.writeFieldEnd()
16736 
    if self.ex is not None:
16737 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16738 
      self.ex.write(oprot)
16739 
      oprot.writeFieldEnd()
16740 
    oprot.writeFieldStop()
16741 
    oprot.writeStructEnd()
16742 
 
16743 
  def validate(self):
16744 
    return
16745 
 
16746 
 
16747 
  def __repr__(self):
16748 
    L = ['%s=%r' % (key, value)
16749 
      for key, value in self.__dict__.iteritems()]
16750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16751 
 
16752 
  def __eq__(self, other):
16753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16754 
 
16755 
  def __ne__(self, other):
16756 
    return not (self == other)
3553 chandransh 16757 
 
16758 
class addDelayReason_args:
16759 
  """
16760 
  Attributes:
16761 
   - orderId
16762 
   - delayReason
3986 chandransh 16763 
   - furtherDelay
4647 rajveer 16764 
   - delayReasonText
3553 chandransh 16765 
  """
16766 
 
16767 
  thrift_spec = (
16768 
    None, # 0
16769 
    (1, TType.I64, 'orderId', None, None, ), # 1
16770 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 16771 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 16772 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 16773 
  )
16774 
 
4647 rajveer 16775 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 16776 
    self.orderId = orderId
16777 
    self.delayReason = delayReason
3986 chandransh 16778 
    self.furtherDelay = furtherDelay
4647 rajveer 16779 
    self.delayReasonText = delayReasonText
3553 chandransh 16780 
 
16781 
  def read(self, iprot):
16782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16784 
      return
16785 
    iprot.readStructBegin()
16786 
    while True:
16787 
      (fname, ftype, fid) = iprot.readFieldBegin()
16788 
      if ftype == TType.STOP:
16789 
        break
16790 
      if fid == 1:
16791 
        if ftype == TType.I64:
16792 
          self.orderId = iprot.readI64();
16793 
        else:
16794 
          iprot.skip(ftype)
16795 
      elif fid == 2:
16796 
        if ftype == TType.I32:
16797 
          self.delayReason = iprot.readI32();
16798 
        else:
16799 
          iprot.skip(ftype)
3986 chandransh 16800 
      elif fid == 3:
16801 
        if ftype == TType.I64:
16802 
          self.furtherDelay = iprot.readI64();
16803 
        else:
16804 
          iprot.skip(ftype)
4647 rajveer 16805 
      elif fid == 4:
16806 
        if ftype == TType.STRING:
16807 
          self.delayReasonText = iprot.readString();
16808 
        else:
16809 
          iprot.skip(ftype)
3553 chandransh 16810 
      else:
16811 
        iprot.skip(ftype)
16812 
      iprot.readFieldEnd()
16813 
    iprot.readStructEnd()
16814 
 
16815 
  def write(self, oprot):
16816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16818 
      return
16819 
    oprot.writeStructBegin('addDelayReason_args')
16820 
    if self.orderId is not None:
16821 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16822 
      oprot.writeI64(self.orderId)
16823 
      oprot.writeFieldEnd()
16824 
    if self.delayReason is not None:
16825 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
16826 
      oprot.writeI32(self.delayReason)
16827 
      oprot.writeFieldEnd()
3986 chandransh 16828 
    if self.furtherDelay is not None:
16829 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
16830 
      oprot.writeI64(self.furtherDelay)
16831 
      oprot.writeFieldEnd()
4647 rajveer 16832 
    if self.delayReasonText is not None:
16833 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
16834 
      oprot.writeString(self.delayReasonText)
16835 
      oprot.writeFieldEnd()
3553 chandransh 16836 
    oprot.writeFieldStop()
16837 
    oprot.writeStructEnd()
16838 
 
16839 
  def validate(self):
16840 
    return
16841 
 
16842 
 
16843 
  def __repr__(self):
16844 
    L = ['%s=%r' % (key, value)
16845 
      for key, value in self.__dict__.iteritems()]
16846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16847 
 
16848 
  def __eq__(self, other):
16849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16850 
 
16851 
  def __ne__(self, other):
16852 
    return not (self == other)
16853 
 
16854 
class addDelayReason_result:
16855 
  """
16856 
  Attributes:
16857 
   - success
16858 
   - ex
16859 
  """
16860 
 
16861 
  thrift_spec = (
16862 
    (0, TType.BOOL, 'success', None, None, ), # 0
16863 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16864 
  )
16865 
 
16866 
  def __init__(self, success=None, ex=None,):
16867 
    self.success = success
16868 
    self.ex = ex
16869 
 
16870 
  def read(self, iprot):
16871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16873 
      return
16874 
    iprot.readStructBegin()
16875 
    while True:
16876 
      (fname, ftype, fid) = iprot.readFieldBegin()
16877 
      if ftype == TType.STOP:
16878 
        break
16879 
      if fid == 0:
16880 
        if ftype == TType.BOOL:
16881 
          self.success = iprot.readBool();
16882 
        else:
16883 
          iprot.skip(ftype)
16884 
      elif fid == 1:
16885 
        if ftype == TType.STRUCT:
16886 
          self.ex = TransactionServiceException()
16887 
          self.ex.read(iprot)
16888 
        else:
16889 
          iprot.skip(ftype)
16890 
      else:
16891 
        iprot.skip(ftype)
16892 
      iprot.readFieldEnd()
16893 
    iprot.readStructEnd()
16894 
 
16895 
  def write(self, oprot):
16896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16898 
      return
16899 
    oprot.writeStructBegin('addDelayReason_result')
16900 
    if self.success is not None:
16901 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16902 
      oprot.writeBool(self.success)
16903 
      oprot.writeFieldEnd()
16904 
    if self.ex is not None:
16905 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16906 
      self.ex.write(oprot)
16907 
      oprot.writeFieldEnd()
16908 
    oprot.writeFieldStop()
16909 
    oprot.writeStructEnd()
16910 
 
16911 
  def validate(self):
16912 
    return
16913 
 
16914 
 
16915 
  def __repr__(self):
16916 
    L = ['%s=%r' % (key, value)
16917 
      for key, value in self.__dict__.iteritems()]
16918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16919 
 
16920 
  def __eq__(self, other):
16921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16922 
 
16923 
  def __ne__(self, other):
16924 
    return not (self == other)
3956 chandransh 16925 
 
16926 
class reconcileCodCollection_args:
16927 
  """
16928 
  Attributes:
16929 
   - collectedAmountMap
16930 
   - xferBy
16931 
   - xferTxnId
16932 
   - xferDate
16933 
  """
16934 
 
16935 
  thrift_spec = (
16936 
    None, # 0
16937 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
16938 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
16939 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
16940 
    (4, TType.I64, 'xferDate', None, None, ), # 4
16941 
  )
16942 
 
16943 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
16944 
    self.collectedAmountMap = collectedAmountMap
16945 
    self.xferBy = xferBy
16946 
    self.xferTxnId = xferTxnId
16947 
    self.xferDate = xferDate
16948 
 
16949 
  def read(self, iprot):
16950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16952 
      return
16953 
    iprot.readStructBegin()
16954 
    while True:
16955 
      (fname, ftype, fid) = iprot.readFieldBegin()
16956 
      if ftype == TType.STOP:
16957 
        break
16958 
      if fid == 1:
16959 
        if ftype == TType.MAP:
16960 
          self.collectedAmountMap = {}
5031 varun.gupt 16961 
          (_ktype362, _vtype363, _size361 ) = iprot.readMapBegin()
16962 
          for _i365 in xrange(_size361):
16963 
            _key366 = iprot.readString();
16964 
            _val367 = iprot.readDouble();
16965 
            self.collectedAmountMap[_key366] = _val367
3956 chandransh 16966 
          iprot.readMapEnd()
16967 
        else:
16968 
          iprot.skip(ftype)
16969 
      elif fid == 2:
16970 
        if ftype == TType.STRING:
16971 
          self.xferBy = iprot.readString();
16972 
        else:
16973 
          iprot.skip(ftype)
16974 
      elif fid == 3:
16975 
        if ftype == TType.STRING:
16976 
          self.xferTxnId = iprot.readString();
16977 
        else:
16978 
          iprot.skip(ftype)
16979 
      elif fid == 4:
16980 
        if ftype == TType.I64:
16981 
          self.xferDate = iprot.readI64();
16982 
        else:
16983 
          iprot.skip(ftype)
16984 
      else:
16985 
        iprot.skip(ftype)
16986 
      iprot.readFieldEnd()
16987 
    iprot.readStructEnd()
16988 
 
16989 
  def write(self, oprot):
16990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16992 
      return
16993 
    oprot.writeStructBegin('reconcileCodCollection_args')
16994 
    if self.collectedAmountMap is not None:
16995 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
16996 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
5031 varun.gupt 16997 
      for kiter368,viter369 in self.collectedAmountMap.items():
16998 
        oprot.writeString(kiter368)
16999 
        oprot.writeDouble(viter369)
3956 chandransh 17000 
      oprot.writeMapEnd()
17001 
      oprot.writeFieldEnd()
17002 
    if self.xferBy is not None:
17003 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
17004 
      oprot.writeString(self.xferBy)
17005 
      oprot.writeFieldEnd()
17006 
    if self.xferTxnId is not None:
17007 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
17008 
      oprot.writeString(self.xferTxnId)
17009 
      oprot.writeFieldEnd()
17010 
    if self.xferDate is not None:
17011 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
17012 
      oprot.writeI64(self.xferDate)
17013 
      oprot.writeFieldEnd()
17014 
    oprot.writeFieldStop()
17015 
    oprot.writeStructEnd()
17016 
 
17017 
  def validate(self):
17018 
    return
17019 
 
17020 
 
17021 
  def __repr__(self):
17022 
    L = ['%s=%r' % (key, value)
17023 
      for key, value in self.__dict__.iteritems()]
17024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17025 
 
17026 
  def __eq__(self, other):
17027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17028 
 
17029 
  def __ne__(self, other):
17030 
    return not (self == other)
17031 
 
17032 
class reconcileCodCollection_result:
17033 
  """
17034 
  Attributes:
17035 
   - success
17036 
   - ex
17037 
  """
17038 
 
17039 
  thrift_spec = (
17040 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
17041 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17042 
  )
17043 
 
17044 
  def __init__(self, success=None, ex=None,):
17045 
    self.success = success
17046 
    self.ex = ex
17047 
 
17048 
  def read(self, iprot):
17049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17051 
      return
17052 
    iprot.readStructBegin()
17053 
    while True:
17054 
      (fname, ftype, fid) = iprot.readFieldBegin()
17055 
      if ftype == TType.STOP:
17056 
        break
17057 
      if fid == 0:
17058 
        if ftype == TType.MAP:
17059 
          self.success = {}
5031 varun.gupt 17060 
          (_ktype371, _vtype372, _size370 ) = iprot.readMapBegin()
17061 
          for _i374 in xrange(_size370):
17062 
            _key375 = iprot.readString();
17063 
            _val376 = iprot.readString();
17064 
            self.success[_key375] = _val376
3956 chandransh 17065 
          iprot.readMapEnd()
17066 
        else:
17067 
          iprot.skip(ftype)
17068 
      elif fid == 1:
17069 
        if ftype == TType.STRUCT:
17070 
          self.ex = TransactionServiceException()
17071 
          self.ex.read(iprot)
17072 
        else:
17073 
          iprot.skip(ftype)
17074 
      else:
17075 
        iprot.skip(ftype)
17076 
      iprot.readFieldEnd()
17077 
    iprot.readStructEnd()
17078 
 
17079 
  def write(self, oprot):
17080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17082 
      return
17083 
    oprot.writeStructBegin('reconcileCodCollection_result')
17084 
    if self.success is not None:
17085 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17086 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
5031 varun.gupt 17087 
      for kiter377,viter378 in self.success.items():
17088 
        oprot.writeString(kiter377)
17089 
        oprot.writeString(viter378)
3956 chandransh 17090 
      oprot.writeMapEnd()
17091 
      oprot.writeFieldEnd()
17092 
    if self.ex is not None:
17093 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17094 
      self.ex.write(oprot)
17095 
      oprot.writeFieldEnd()
17096 
    oprot.writeFieldStop()
17097 
    oprot.writeStructEnd()
17098 
 
17099 
  def validate(self):
17100 
    return
17101 
 
17102 
 
17103 
  def __repr__(self):
17104 
    L = ['%s=%r' % (key, value)
17105 
      for key, value in self.__dict__.iteritems()]
17106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17107 
 
17108 
  def __eq__(self, other):
17109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17110 
 
17111 
  def __ne__(self, other):
17112 
    return not (self == other)
4008 mandeep.dh 17113 
 
17114 
class getTransactionsRequiringExtraProcessing_args:
17115 
  """
17116 
  Attributes:
17117 
   - category
17118 
  """
17119 
 
17120 
  thrift_spec = (
17121 
    None, # 0
17122 
    (1, TType.I32, 'category', None, None, ), # 1
17123 
  )
17124 
 
17125 
  def __init__(self, category=None,):
17126 
    self.category = category
17127 
 
17128 
  def read(self, iprot):
17129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17131 
      return
17132 
    iprot.readStructBegin()
17133 
    while True:
17134 
      (fname, ftype, fid) = iprot.readFieldBegin()
17135 
      if ftype == TType.STOP:
17136 
        break
17137 
      if fid == 1:
17138 
        if ftype == TType.I32:
17139 
          self.category = iprot.readI32();
17140 
        else:
17141 
          iprot.skip(ftype)
17142 
      else:
17143 
        iprot.skip(ftype)
17144 
      iprot.readFieldEnd()
17145 
    iprot.readStructEnd()
17146 
 
17147 
  def write(self, oprot):
17148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17150 
      return
17151 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
17152 
    if self.category is not None:
17153 
      oprot.writeFieldBegin('category', TType.I32, 1)
17154 
      oprot.writeI32(self.category)
17155 
      oprot.writeFieldEnd()
17156 
    oprot.writeFieldStop()
17157 
    oprot.writeStructEnd()
17158 
 
17159 
  def validate(self):
17160 
    return
17161 
 
17162 
 
17163 
  def __repr__(self):
17164 
    L = ['%s=%r' % (key, value)
17165 
      for key, value in self.__dict__.iteritems()]
17166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17167 
 
17168 
  def __eq__(self, other):
17169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17170 
 
17171 
  def __ne__(self, other):
17172 
    return not (self == other)
17173 
 
17174 
class getTransactionsRequiringExtraProcessing_result:
17175 
  """
17176 
  Attributes:
17177 
   - success
17178 
  """
17179 
 
17180 
  thrift_spec = (
17181 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
17182 
  )
17183 
 
17184 
  def __init__(self, success=None,):
17185 
    self.success = success
17186 
 
17187 
  def read(self, iprot):
17188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17190 
      return
17191 
    iprot.readStructBegin()
17192 
    while True:
17193 
      (fname, ftype, fid) = iprot.readFieldBegin()
17194 
      if ftype == TType.STOP:
17195 
        break
17196 
      if fid == 0:
17197 
        if ftype == TType.LIST:
17198 
          self.success = []
5031 varun.gupt 17199 
          (_etype382, _size379) = iprot.readListBegin()
17200 
          for _i383 in xrange(_size379):
17201 
            _elem384 = iprot.readI64();
17202 
            self.success.append(_elem384)
4008 mandeep.dh 17203 
          iprot.readListEnd()
17204 
        else:
17205 
          iprot.skip(ftype)
17206 
      else:
17207 
        iprot.skip(ftype)
17208 
      iprot.readFieldEnd()
17209 
    iprot.readStructEnd()
17210 
 
17211 
  def write(self, oprot):
17212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17214 
      return
17215 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
17216 
    if self.success is not None:
17217 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17218 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 17219 
      for iter385 in self.success:
17220 
        oprot.writeI64(iter385)
4008 mandeep.dh 17221 
      oprot.writeListEnd()
17222 
      oprot.writeFieldEnd()
17223 
    oprot.writeFieldStop()
17224 
    oprot.writeStructEnd()
17225 
 
17226 
  def validate(self):
17227 
    return
17228 
 
17229 
 
17230 
  def __repr__(self):
17231 
    L = ['%s=%r' % (key, value)
17232 
      for key, value in self.__dict__.iteritems()]
17233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17234 
 
17235 
  def __eq__(self, other):
17236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17237 
 
17238 
  def __ne__(self, other):
17239 
    return not (self == other)
17240 
 
17241 
class markTransactionAsProcessed_args:
17242 
  """
17243 
  Attributes:
17244 
   - transactionId
17245 
   - category
17246 
  """
17247 
 
17248 
  thrift_spec = (
17249 
    None, # 0
17250 
    (1, TType.I64, 'transactionId', None, None, ), # 1
17251 
    (2, TType.I32, 'category', None, None, ), # 2
17252 
  )
17253 
 
17254 
  def __init__(self, transactionId=None, category=None,):
17255 
    self.transactionId = transactionId
17256 
    self.category = category
17257 
 
17258 
  def read(self, iprot):
17259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17261 
      return
17262 
    iprot.readStructBegin()
17263 
    while True:
17264 
      (fname, ftype, fid) = iprot.readFieldBegin()
17265 
      if ftype == TType.STOP:
17266 
        break
17267 
      if fid == 1:
17268 
        if ftype == TType.I64:
17269 
          self.transactionId = iprot.readI64();
17270 
        else:
17271 
          iprot.skip(ftype)
17272 
      elif fid == 2:
17273 
        if ftype == TType.I32:
17274 
          self.category = iprot.readI32();
17275 
        else:
17276 
          iprot.skip(ftype)
17277 
      else:
17278 
        iprot.skip(ftype)
17279 
      iprot.readFieldEnd()
17280 
    iprot.readStructEnd()
17281 
 
17282 
  def write(self, oprot):
17283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17285 
      return
17286 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
17287 
    if self.transactionId is not None:
17288 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
17289 
      oprot.writeI64(self.transactionId)
17290 
      oprot.writeFieldEnd()
17291 
    if self.category is not None:
17292 
      oprot.writeFieldBegin('category', TType.I32, 2)
17293 
      oprot.writeI32(self.category)
17294 
      oprot.writeFieldEnd()
17295 
    oprot.writeFieldStop()
17296 
    oprot.writeStructEnd()
17297 
 
17298 
  def validate(self):
17299 
    return
17300 
 
17301 
 
17302 
  def __repr__(self):
17303 
    L = ['%s=%r' % (key, value)
17304 
      for key, value in self.__dict__.iteritems()]
17305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17306 
 
17307 
  def __eq__(self, other):
17308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17309 
 
17310 
  def __ne__(self, other):
17311 
    return not (self == other)
17312 
 
17313 
class markTransactionAsProcessed_result:
17314 
 
17315 
  thrift_spec = (
17316 
  )
17317 
 
17318 
  def read(self, iprot):
17319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17321 
      return
17322 
    iprot.readStructBegin()
17323 
    while True:
17324 
      (fname, ftype, fid) = iprot.readFieldBegin()
17325 
      if ftype == TType.STOP:
17326 
        break
17327 
      else:
17328 
        iprot.skip(ftype)
17329 
      iprot.readFieldEnd()
17330 
    iprot.readStructEnd()
17331 
 
17332 
  def write(self, oprot):
17333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17335 
      return
17336 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
17337 
    oprot.writeFieldStop()
17338 
    oprot.writeStructEnd()
17339 
 
17340 
  def validate(self):
17341 
    return
17342 
 
17343 
 
17344 
  def __repr__(self):
17345 
    L = ['%s=%r' % (key, value)
17346 
      for key, value in self.__dict__.iteritems()]
17347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17348 
 
17349 
  def __eq__(self, other):
17350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17351 
 
17352 
  def __ne__(self, other):
17353 
    return not (self == other)
4018 chandransh 17354 
 
17355 
class getItemWiseRiskyOrdersCount_args:
17356 
 
17357 
  thrift_spec = (
17358 
  )
17359 
 
17360 
  def read(self, iprot):
17361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17363 
      return
17364 
    iprot.readStructBegin()
17365 
    while True:
17366 
      (fname, ftype, fid) = iprot.readFieldBegin()
17367 
      if ftype == TType.STOP:
17368 
        break
17369 
      else:
17370 
        iprot.skip(ftype)
17371 
      iprot.readFieldEnd()
17372 
    iprot.readStructEnd()
17373 
 
17374 
  def write(self, oprot):
17375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17377 
      return
17378 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
17379 
    oprot.writeFieldStop()
17380 
    oprot.writeStructEnd()
17381 
 
17382 
  def validate(self):
17383 
    return
17384 
 
17385 
 
17386 
  def __repr__(self):
17387 
    L = ['%s=%r' % (key, value)
17388 
      for key, value in self.__dict__.iteritems()]
17389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17390 
 
17391 
  def __eq__(self, other):
17392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17393 
 
17394 
  def __ne__(self, other):
17395 
    return not (self == other)
17396 
 
17397 
class getItemWiseRiskyOrdersCount_result:
17398 
  """
17399 
  Attributes:
17400 
   - success
17401 
  """
17402 
 
17403 
  thrift_spec = (
17404 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
17405 
  )
17406 
 
17407 
  def __init__(self, success=None,):
17408 
    self.success = success
17409 
 
17410 
  def read(self, iprot):
17411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17413 
      return
17414 
    iprot.readStructBegin()
17415 
    while True:
17416 
      (fname, ftype, fid) = iprot.readFieldBegin()
17417 
      if ftype == TType.STOP:
17418 
        break
17419 
      if fid == 0:
17420 
        if ftype == TType.MAP:
17421 
          self.success = {}
5031 varun.gupt 17422 
          (_ktype387, _vtype388, _size386 ) = iprot.readMapBegin()
17423 
          for _i390 in xrange(_size386):
17424 
            _key391 = iprot.readI64();
17425 
            _val392 = iprot.readI64();
17426 
            self.success[_key391] = _val392
4018 chandransh 17427 
          iprot.readMapEnd()
17428 
        else:
17429 
          iprot.skip(ftype)
17430 
      else:
17431 
        iprot.skip(ftype)
17432 
      iprot.readFieldEnd()
17433 
    iprot.readStructEnd()
17434 
 
17435 
  def write(self, oprot):
17436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17438 
      return
17439 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
17440 
    if self.success is not None:
17441 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17442 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5031 varun.gupt 17443 
      for kiter393,viter394 in self.success.items():
17444 
        oprot.writeI64(kiter393)
17445 
        oprot.writeI64(viter394)
4018 chandransh 17446 
      oprot.writeMapEnd()
17447 
      oprot.writeFieldEnd()
17448 
    oprot.writeFieldStop()
17449 
    oprot.writeStructEnd()
17450 
 
17451 
  def validate(self):
17452 
    return
17453 
 
17454 
 
17455 
  def __repr__(self):
17456 
    L = ['%s=%r' % (key, value)
17457 
      for key, value in self.__dict__.iteritems()]
17458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17459 
 
17460 
  def __eq__(self, other):
17461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17462 
 
17463 
  def __ne__(self, other):
17464 
    return not (self == other)
4247 rajveer 17465 
 
4295 varun.gupt 17466 
class getOrdersForItemIds_args:
17467 
  """
17468 
  Attributes:
17469 
   - itemIds
17470 
  """
17471 
 
17472 
  thrift_spec = (
17473 
    None, # 0
17474 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
17475 
  )
17476 
 
17477 
  def __init__(self, itemIds=None,):
17478 
    self.itemIds = itemIds
17479 
 
17480 
  def read(self, iprot):
17481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17483 
      return
17484 
    iprot.readStructBegin()
17485 
    while True:
17486 
      (fname, ftype, fid) = iprot.readFieldBegin()
17487 
      if ftype == TType.STOP:
17488 
        break
17489 
      if fid == 1:
17490 
        if ftype == TType.LIST:
17491 
          self.itemIds = []
5031 varun.gupt 17492 
          (_etype398, _size395) = iprot.readListBegin()
17493 
          for _i399 in xrange(_size395):
17494 
            _elem400 = iprot.readI64();
17495 
            self.itemIds.append(_elem400)
4295 varun.gupt 17496 
          iprot.readListEnd()
17497 
        else:
17498 
          iprot.skip(ftype)
17499 
      else:
17500 
        iprot.skip(ftype)
17501 
      iprot.readFieldEnd()
17502 
    iprot.readStructEnd()
17503 
 
17504 
  def write(self, oprot):
17505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17507 
      return
17508 
    oprot.writeStructBegin('getOrdersForItemIds_args')
17509 
    if self.itemIds is not None:
17510 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
17511 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5031 varun.gupt 17512 
      for iter401 in self.itemIds:
17513 
        oprot.writeI64(iter401)
4295 varun.gupt 17514 
      oprot.writeListEnd()
17515 
      oprot.writeFieldEnd()
17516 
    oprot.writeFieldStop()
17517 
    oprot.writeStructEnd()
17518 
 
17519 
  def validate(self):
17520 
    return
17521 
 
17522 
 
17523 
  def __repr__(self):
17524 
    L = ['%s=%r' % (key, value)
17525 
      for key, value in self.__dict__.iteritems()]
17526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17527 
 
17528 
  def __eq__(self, other):
17529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17530 
 
17531 
  def __ne__(self, other):
17532 
    return not (self == other)
17533 
 
17534 
class getOrdersForItemIds_result:
17535 
  """
17536 
  Attributes:
17537 
   - success
17538 
  """
17539 
 
17540 
  thrift_spec = (
17541 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17542 
  )
17543 
 
17544 
  def __init__(self, success=None,):
17545 
    self.success = success
17546 
 
17547 
  def read(self, iprot):
17548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17550 
      return
17551 
    iprot.readStructBegin()
17552 
    while True:
17553 
      (fname, ftype, fid) = iprot.readFieldBegin()
17554 
      if ftype == TType.STOP:
17555 
        break
17556 
      if fid == 0:
17557 
        if ftype == TType.LIST:
17558 
          self.success = []
5031 varun.gupt 17559 
          (_etype405, _size402) = iprot.readListBegin()
17560 
          for _i406 in xrange(_size402):
17561 
            _elem407 = Order()
17562 
            _elem407.read(iprot)
17563 
            self.success.append(_elem407)
4295 varun.gupt 17564 
          iprot.readListEnd()
17565 
        else:
17566 
          iprot.skip(ftype)
17567 
      else:
17568 
        iprot.skip(ftype)
17569 
      iprot.readFieldEnd()
17570 
    iprot.readStructEnd()
17571 
 
17572 
  def write(self, oprot):
17573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17575 
      return
17576 
    oprot.writeStructBegin('getOrdersForItemIds_result')
17577 
    if self.success is not None:
17578 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17579 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 17580 
      for iter408 in self.success:
17581 
        iter408.write(oprot)
4295 varun.gupt 17582 
      oprot.writeListEnd()
17583 
      oprot.writeFieldEnd()
17584 
    oprot.writeFieldStop()
17585 
    oprot.writeStructEnd()
17586 
 
17587 
  def validate(self):
17588 
    return
17589 
 
17590 
 
17591 
  def __repr__(self):
17592 
    L = ['%s=%r' % (key, value)
17593 
      for key, value in self.__dict__.iteritems()]
17594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17595 
 
17596 
  def __eq__(self, other):
17597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17598 
 
17599 
  def __ne__(self, other):
17600 
    return not (self == other)
17601 
 
4247 rajveer 17602 
class markOrderCancellationRequestReceived_args:
17603 
  """
17604 
  Attributes:
17605 
   - orderId
17606 
  """
17607 
 
17608 
  thrift_spec = (
17609 
    None, # 0
17610 
    (1, TType.I64, 'orderId', None, None, ), # 1
17611 
  )
17612 
 
17613 
  def __init__(self, orderId=None,):
17614 
    self.orderId = orderId
17615 
 
17616 
  def read(self, iprot):
17617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17619 
      return
17620 
    iprot.readStructBegin()
17621 
    while True:
17622 
      (fname, ftype, fid) = iprot.readFieldBegin()
17623 
      if ftype == TType.STOP:
17624 
        break
17625 
      if fid == 1:
17626 
        if ftype == TType.I64:
17627 
          self.orderId = iprot.readI64();
17628 
        else:
17629 
          iprot.skip(ftype)
17630 
      else:
17631 
        iprot.skip(ftype)
17632 
      iprot.readFieldEnd()
17633 
    iprot.readStructEnd()
17634 
 
17635 
  def write(self, oprot):
17636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17638 
      return
17639 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
17640 
    if self.orderId is not None:
17641 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17642 
      oprot.writeI64(self.orderId)
17643 
      oprot.writeFieldEnd()
17644 
    oprot.writeFieldStop()
17645 
    oprot.writeStructEnd()
17646 
 
17647 
  def validate(self):
17648 
    return
17649 
 
17650 
 
17651 
  def __repr__(self):
17652 
    L = ['%s=%r' % (key, value)
17653 
      for key, value in self.__dict__.iteritems()]
17654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17655 
 
17656 
  def __eq__(self, other):
17657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17658 
 
17659 
  def __ne__(self, other):
17660 
    return not (self == other)
17661 
 
17662 
class markOrderCancellationRequestReceived_result:
17663 
  """
17664 
  Attributes:
17665 
   - ex
17666 
  """
17667 
 
17668 
  thrift_spec = (
17669 
    None, # 0
17670 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17671 
  )
17672 
 
17673 
  def __init__(self, ex=None,):
17674 
    self.ex = ex
17675 
 
17676 
  def read(self, iprot):
17677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17679 
      return
17680 
    iprot.readStructBegin()
17681 
    while True:
17682 
      (fname, ftype, fid) = iprot.readFieldBegin()
17683 
      if ftype == TType.STOP:
17684 
        break
17685 
      if fid == 1:
17686 
        if ftype == TType.STRUCT:
17687 
          self.ex = TransactionServiceException()
17688 
          self.ex.read(iprot)
17689 
        else:
17690 
          iprot.skip(ftype)
17691 
      else:
17692 
        iprot.skip(ftype)
17693 
      iprot.readFieldEnd()
17694 
    iprot.readStructEnd()
17695 
 
17696 
  def write(self, oprot):
17697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17699 
      return
17700 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
17701 
    if self.ex is not None:
17702 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17703 
      self.ex.write(oprot)
17704 
      oprot.writeFieldEnd()
17705 
    oprot.writeFieldStop()
17706 
    oprot.writeStructEnd()
17707 
 
17708 
  def validate(self):
17709 
    return
17710 
 
17711 
 
17712 
  def __repr__(self):
17713 
    L = ['%s=%r' % (key, value)
17714 
      for key, value in self.__dict__.iteritems()]
17715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17716 
 
17717 
  def __eq__(self, other):
17718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17719 
 
17720 
  def __ne__(self, other):
17721 
    return not (self == other)
17722 
 
17723 
class markOrderCancellationRequestConfirmed_args:
17724 
  """
17725 
  Attributes:
17726 
   - orderId
17727 
  """
17728 
 
17729 
  thrift_spec = (
17730 
    None, # 0
17731 
    (1, TType.I64, 'orderId', None, None, ), # 1
17732 
  )
17733 
 
17734 
  def __init__(self, orderId=None,):
17735 
    self.orderId = orderId
17736 
 
17737 
  def read(self, iprot):
17738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17740 
      return
17741 
    iprot.readStructBegin()
17742 
    while True:
17743 
      (fname, ftype, fid) = iprot.readFieldBegin()
17744 
      if ftype == TType.STOP:
17745 
        break
17746 
      if fid == 1:
17747 
        if ftype == TType.I64:
17748 
          self.orderId = iprot.readI64();
17749 
        else:
17750 
          iprot.skip(ftype)
17751 
      else:
17752 
        iprot.skip(ftype)
17753 
      iprot.readFieldEnd()
17754 
    iprot.readStructEnd()
17755 
 
17756 
  def write(self, oprot):
17757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17759 
      return
17760 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
17761 
    if self.orderId is not None:
17762 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17763 
      oprot.writeI64(self.orderId)
17764 
      oprot.writeFieldEnd()
17765 
    oprot.writeFieldStop()
17766 
    oprot.writeStructEnd()
17767 
 
17768 
  def validate(self):
17769 
    return
17770 
 
17771 
 
17772 
  def __repr__(self):
17773 
    L = ['%s=%r' % (key, value)
17774 
      for key, value in self.__dict__.iteritems()]
17775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17776 
 
17777 
  def __eq__(self, other):
17778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17779 
 
17780 
  def __ne__(self, other):
17781 
    return not (self == other)
17782 
 
17783 
class markOrderCancellationRequestConfirmed_result:
17784 
  """
17785 
  Attributes:
17786 
   - ex
17787 
  """
17788 
 
17789 
  thrift_spec = (
17790 
    None, # 0
17791 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17792 
  )
17793 
 
17794 
  def __init__(self, ex=None,):
17795 
    self.ex = ex
17796 
 
17797 
  def read(self, iprot):
17798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17800 
      return
17801 
    iprot.readStructBegin()
17802 
    while True:
17803 
      (fname, ftype, fid) = iprot.readFieldBegin()
17804 
      if ftype == TType.STOP:
17805 
        break
17806 
      if fid == 1:
17807 
        if ftype == TType.STRUCT:
17808 
          self.ex = TransactionServiceException()
17809 
          self.ex.read(iprot)
17810 
        else:
17811 
          iprot.skip(ftype)
17812 
      else:
17813 
        iprot.skip(ftype)
17814 
      iprot.readFieldEnd()
17815 
    iprot.readStructEnd()
17816 
 
17817 
  def write(self, oprot):
17818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17820 
      return
17821 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
17822 
    if self.ex is not None:
17823 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17824 
      self.ex.write(oprot)
17825 
      oprot.writeFieldEnd()
17826 
    oprot.writeFieldStop()
17827 
    oprot.writeStructEnd()
17828 
 
17829 
  def validate(self):
17830 
    return
17831 
 
17832 
 
17833 
  def __repr__(self):
17834 
    L = ['%s=%r' % (key, value)
17835 
      for key, value in self.__dict__.iteritems()]
17836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17837 
 
17838 
  def __eq__(self, other):
17839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17840 
 
17841 
  def __ne__(self, other):
17842 
    return not (self == other)
17843 
 
17844 
class markOrderCancellationRequestDenied_args:
17845 
  """
17846 
  Attributes:
17847 
   - orderId
17848 
  """
17849 
 
17850 
  thrift_spec = (
17851 
    None, # 0
17852 
    (1, TType.I64, 'orderId', None, None, ), # 1
17853 
  )
17854 
 
17855 
  def __init__(self, orderId=None,):
17856 
    self.orderId = orderId
17857 
 
17858 
  def read(self, iprot):
17859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17861 
      return
17862 
    iprot.readStructBegin()
17863 
    while True:
17864 
      (fname, ftype, fid) = iprot.readFieldBegin()
17865 
      if ftype == TType.STOP:
17866 
        break
17867 
      if fid == 1:
17868 
        if ftype == TType.I64:
17869 
          self.orderId = iprot.readI64();
17870 
        else:
17871 
          iprot.skip(ftype)
17872 
      else:
17873 
        iprot.skip(ftype)
17874 
      iprot.readFieldEnd()
17875 
    iprot.readStructEnd()
17876 
 
17877 
  def write(self, oprot):
17878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17880 
      return
17881 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
17882 
    if self.orderId is not None:
17883 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17884 
      oprot.writeI64(self.orderId)
17885 
      oprot.writeFieldEnd()
17886 
    oprot.writeFieldStop()
17887 
    oprot.writeStructEnd()
17888 
 
17889 
  def validate(self):
17890 
    return
17891 
 
17892 
 
17893 
  def __repr__(self):
17894 
    L = ['%s=%r' % (key, value)
17895 
      for key, value in self.__dict__.iteritems()]
17896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17897 
 
17898 
  def __eq__(self, other):
17899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17900 
 
17901 
  def __ne__(self, other):
17902 
    return not (self == other)
17903 
 
17904 
class markOrderCancellationRequestDenied_result:
17905 
  """
17906 
  Attributes:
17907 
   - ex
17908 
  """
17909 
 
17910 
  thrift_spec = (
17911 
    None, # 0
17912 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17913 
  )
17914 
 
17915 
  def __init__(self, ex=None,):
17916 
    self.ex = ex
17917 
 
17918 
  def read(self, iprot):
17919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17921 
      return
17922 
    iprot.readStructBegin()
17923 
    while True:
17924 
      (fname, ftype, fid) = iprot.readFieldBegin()
17925 
      if ftype == TType.STOP:
17926 
        break
17927 
      if fid == 1:
17928 
        if ftype == TType.STRUCT:
17929 
          self.ex = TransactionServiceException()
17930 
          self.ex.read(iprot)
17931 
        else:
17932 
          iprot.skip(ftype)
17933 
      else:
17934 
        iprot.skip(ftype)
17935 
      iprot.readFieldEnd()
17936 
    iprot.readStructEnd()
17937 
 
17938 
  def write(self, oprot):
17939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17941 
      return
17942 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
17943 
    if self.ex is not None:
17944 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17945 
      self.ex.write(oprot)
17946 
      oprot.writeFieldEnd()
17947 
    oprot.writeFieldStop()
17948 
    oprot.writeStructEnd()
17949 
 
17950 
  def validate(self):
17951 
    return
17952 
 
17953 
 
17954 
  def __repr__(self):
17955 
    L = ['%s=%r' % (key, value)
17956 
      for key, value in self.__dict__.iteritems()]
17957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17958 
 
17959 
  def __eq__(self, other):
17960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17961 
 
17962 
  def __ne__(self, other):
17963 
    return not (self == other)
17964 
 
4258 rajveer 17965 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 17966 
  """
17967 
  Attributes:
4258 rajveer 17968 
   - transactionId
4247 rajveer 17969 
  """
17970 
 
17971 
  thrift_spec = (
17972 
    None, # 0
4258 rajveer 17973 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 17974 
  )
17975 
 
4258 rajveer 17976 
  def __init__(self, transactionId=None,):
17977 
    self.transactionId = transactionId
4247 rajveer 17978 
 
17979 
  def read(self, iprot):
17980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17982 
      return
17983 
    iprot.readStructBegin()
17984 
    while True:
17985 
      (fname, ftype, fid) = iprot.readFieldBegin()
17986 
      if ftype == TType.STOP:
17987 
        break
17988 
      if fid == 1:
17989 
        if ftype == TType.I64:
4258 rajveer 17990 
          self.transactionId = iprot.readI64();
4247 rajveer 17991 
        else:
17992 
          iprot.skip(ftype)
17993 
      else:
17994 
        iprot.skip(ftype)
17995 
      iprot.readFieldEnd()
17996 
    iprot.readStructEnd()
17997 
 
17998 
  def write(self, oprot):
17999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18001 
      return
4258 rajveer 18002 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
18003 
    if self.transactionId is not None:
18004 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18005 
      oprot.writeI64(self.transactionId)
4247 rajveer 18006 
      oprot.writeFieldEnd()
18007 
    oprot.writeFieldStop()
18008 
    oprot.writeStructEnd()
18009 
 
18010 
  def validate(self):
18011 
    return
18012 
 
18013 
 
18014 
  def __repr__(self):
18015 
    L = ['%s=%r' % (key, value)
18016 
      for key, value in self.__dict__.iteritems()]
18017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18018 
 
18019 
  def __eq__(self, other):
18020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18021 
 
18022 
  def __ne__(self, other):
18023 
    return not (self == other)
18024 
 
4258 rajveer 18025 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 18026 
  """
18027 
  Attributes:
18028 
   - ex
18029 
  """
18030 
 
18031 
  thrift_spec = (
18032 
    None, # 0
18033 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18034 
  )
18035 
 
18036 
  def __init__(self, ex=None,):
18037 
    self.ex = ex
18038 
 
18039 
  def read(self, iprot):
18040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18042 
      return
18043 
    iprot.readStructBegin()
18044 
    while True:
18045 
      (fname, ftype, fid) = iprot.readFieldBegin()
18046 
      if ftype == TType.STOP:
18047 
        break
18048 
      if fid == 1:
18049 
        if ftype == TType.STRUCT:
18050 
          self.ex = TransactionServiceException()
18051 
          self.ex.read(iprot)
18052 
        else:
18053 
          iprot.skip(ftype)
18054 
      else:
18055 
        iprot.skip(ftype)
18056 
      iprot.readFieldEnd()
18057 
    iprot.readStructEnd()
18058 
 
18059 
  def write(self, oprot):
18060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18062 
      return
4258 rajveer 18063 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 18064 
    if self.ex is not None:
18065 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18066 
      self.ex.write(oprot)
18067 
      oprot.writeFieldEnd()
18068 
    oprot.writeFieldStop()
18069 
    oprot.writeStructEnd()
18070 
 
18071 
  def validate(self):
18072 
    return
18073 
 
18074 
 
18075 
  def __repr__(self):
18076 
    L = ['%s=%r' % (key, value)
18077 
      for key, value in self.__dict__.iteritems()]
18078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18079 
 
18080 
  def __eq__(self, other):
18081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18082 
 
18083 
  def __ne__(self, other):
18084 
    return not (self == other)
4259 anupam.sin 18085 
 
18086 
class refundTransaction_args:
18087 
  """
18088 
  Attributes:
18089 
   - transactionId
18090 
   - refundedBy
18091 
   - reason
18092 
  """
18093 
 
18094 
  thrift_spec = (
18095 
    None, # 0
18096 
    (1, TType.I64, 'transactionId', None, None, ), # 1
18097 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18098 
    (3, TType.STRING, 'reason', None, None, ), # 3
18099 
  )
18100 
 
18101 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
18102 
    self.transactionId = transactionId
18103 
    self.refundedBy = refundedBy
18104 
    self.reason = reason
18105 
 
18106 
  def read(self, iprot):
18107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18109 
      return
18110 
    iprot.readStructBegin()
18111 
    while True:
18112 
      (fname, ftype, fid) = iprot.readFieldBegin()
18113 
      if ftype == TType.STOP:
18114 
        break
18115 
      if fid == 1:
18116 
        if ftype == TType.I64:
18117 
          self.transactionId = iprot.readI64();
18118 
        else:
18119 
          iprot.skip(ftype)
18120 
      elif fid == 2:
18121 
        if ftype == TType.STRING:
18122 
          self.refundedBy = iprot.readString();
18123 
        else:
18124 
          iprot.skip(ftype)
18125 
      elif fid == 3:
18126 
        if ftype == TType.STRING:
18127 
          self.reason = iprot.readString();
18128 
        else:
18129 
          iprot.skip(ftype)
18130 
      else:
18131 
        iprot.skip(ftype)
18132 
      iprot.readFieldEnd()
18133 
    iprot.readStructEnd()
18134 
 
18135 
  def write(self, oprot):
18136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18138 
      return
18139 
    oprot.writeStructBegin('refundTransaction_args')
18140 
    if self.transactionId is not None:
18141 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18142 
      oprot.writeI64(self.transactionId)
18143 
      oprot.writeFieldEnd()
18144 
    if self.refundedBy is not None:
18145 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18146 
      oprot.writeString(self.refundedBy)
18147 
      oprot.writeFieldEnd()
18148 
    if self.reason is not None:
18149 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18150 
      oprot.writeString(self.reason)
18151 
      oprot.writeFieldEnd()
18152 
    oprot.writeFieldStop()
18153 
    oprot.writeStructEnd()
18154 
 
18155 
  def validate(self):
18156 
    return
18157 
 
18158 
 
18159 
  def __repr__(self):
18160 
    L = ['%s=%r' % (key, value)
18161 
      for key, value in self.__dict__.iteritems()]
18162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18163 
 
18164 
  def __eq__(self, other):
18165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18166 
 
18167 
  def __ne__(self, other):
18168 
    return not (self == other)
18169 
 
18170 
class refundTransaction_result:
18171 
  """
18172 
  Attributes:
18173 
   - ex
18174 
  """
18175 
 
18176 
  thrift_spec = (
18177 
    None, # 0
18178 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18179 
  )
18180 
 
18181 
  def __init__(self, ex=None,):
18182 
    self.ex = ex
18183 
 
18184 
  def read(self, iprot):
18185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18187 
      return
18188 
    iprot.readStructBegin()
18189 
    while True:
18190 
      (fname, ftype, fid) = iprot.readFieldBegin()
18191 
      if ftype == TType.STOP:
18192 
        break
18193 
      if fid == 1:
18194 
        if ftype == TType.STRUCT:
18195 
          self.ex = TransactionServiceException()
18196 
          self.ex.read(iprot)
18197 
        else:
18198 
          iprot.skip(ftype)
18199 
      else:
18200 
        iprot.skip(ftype)
18201 
      iprot.readFieldEnd()
18202 
    iprot.readStructEnd()
18203 
 
18204 
  def write(self, oprot):
18205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18207 
      return
18208 
    oprot.writeStructBegin('refundTransaction_result')
18209 
    if self.ex is not None:
18210 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18211 
      self.ex.write(oprot)
18212 
      oprot.writeFieldEnd()
18213 
    oprot.writeFieldStop()
18214 
    oprot.writeStructEnd()
18215 
 
18216 
  def validate(self):
18217 
    return
18218 
 
18219 
 
18220 
  def __repr__(self):
18221 
    L = ['%s=%r' % (key, value)
18222 
      for key, value in self.__dict__.iteritems()]
18223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18224 
 
18225 
  def __eq__(self, other):
18226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18227 
 
18228 
  def __ne__(self, other):
18229 
    return not (self == other)
4285 rajveer 18230 
 
4324 mandeep.dh 18231 
class updateShipmentAddress_args:
18232 
  """
18233 
  Attributes:
18234 
   - orderId
18235 
   - addressId
18236 
  """
18237 
 
18238 
  thrift_spec = (
18239 
    None, # 0
18240 
    (1, TType.I64, 'orderId', None, None, ), # 1
18241 
    (2, TType.I64, 'addressId', None, None, ), # 2
18242 
  )
18243 
 
18244 
  def __init__(self, orderId=None, addressId=None,):
18245 
    self.orderId = orderId
18246 
    self.addressId = addressId
18247 
 
18248 
  def read(self, iprot):
18249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18251 
      return
18252 
    iprot.readStructBegin()
18253 
    while True:
18254 
      (fname, ftype, fid) = iprot.readFieldBegin()
18255 
      if ftype == TType.STOP:
18256 
        break
18257 
      if fid == 1:
18258 
        if ftype == TType.I64:
18259 
          self.orderId = iprot.readI64();
18260 
        else:
18261 
          iprot.skip(ftype)
18262 
      elif fid == 2:
18263 
        if ftype == TType.I64:
18264 
          self.addressId = iprot.readI64();
18265 
        else:
18266 
          iprot.skip(ftype)
18267 
      else:
18268 
        iprot.skip(ftype)
18269 
      iprot.readFieldEnd()
18270 
    iprot.readStructEnd()
18271 
 
18272 
  def write(self, oprot):
18273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18275 
      return
18276 
    oprot.writeStructBegin('updateShipmentAddress_args')
18277 
    if self.orderId is not None:
18278 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18279 
      oprot.writeI64(self.orderId)
18280 
      oprot.writeFieldEnd()
18281 
    if self.addressId is not None:
18282 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
18283 
      oprot.writeI64(self.addressId)
18284 
      oprot.writeFieldEnd()
18285 
    oprot.writeFieldStop()
18286 
    oprot.writeStructEnd()
18287 
 
18288 
  def validate(self):
18289 
    return
18290 
 
18291 
 
18292 
  def __repr__(self):
18293 
    L = ['%s=%r' % (key, value)
18294 
      for key, value in self.__dict__.iteritems()]
18295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18296 
 
18297 
  def __eq__(self, other):
18298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18299 
 
18300 
  def __ne__(self, other):
18301 
    return not (self == other)
18302 
 
18303 
class updateShipmentAddress_result:
18304 
  """
18305 
  Attributes:
18306 
   - ex
18307 
  """
18308 
 
18309 
  thrift_spec = (
18310 
    None, # 0
18311 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18312 
  )
18313 
 
18314 
  def __init__(self, ex=None,):
18315 
    self.ex = ex
18316 
 
18317 
  def read(self, iprot):
18318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18320 
      return
18321 
    iprot.readStructBegin()
18322 
    while True:
18323 
      (fname, ftype, fid) = iprot.readFieldBegin()
18324 
      if ftype == TType.STOP:
18325 
        break
18326 
      if fid == 1:
18327 
        if ftype == TType.STRUCT:
18328 
          self.ex = TransactionServiceException()
18329 
          self.ex.read(iprot)
18330 
        else:
18331 
          iprot.skip(ftype)
18332 
      else:
18333 
        iprot.skip(ftype)
18334 
      iprot.readFieldEnd()
18335 
    iprot.readStructEnd()
18336 
 
18337 
  def write(self, oprot):
18338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18340 
      return
18341 
    oprot.writeStructBegin('updateShipmentAddress_result')
18342 
    if self.ex is not None:
18343 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18344 
      self.ex.write(oprot)
18345 
      oprot.writeFieldEnd()
18346 
    oprot.writeFieldStop()
18347 
    oprot.writeStructEnd()
18348 
 
18349 
  def validate(self):
18350 
    return
18351 
 
18352 
 
18353 
  def __repr__(self):
18354 
    L = ['%s=%r' % (key, value)
18355 
      for key, value in self.__dict__.iteritems()]
18356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18357 
 
18358 
  def __eq__(self, other):
18359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18360 
 
18361 
  def __ne__(self, other):
18362 
    return not (self == other)
18363 
 
4285 rajveer 18364 
class acceptOrdersForItemId_args:
18365 
  """
18366 
  Attributes:
18367 
   - itemId
18368 
   - inventory
18369 
  """
18370 
 
18371 
  thrift_spec = (
18372 
    None, # 0
18373 
    (1, TType.I64, 'itemId', None, None, ), # 1
18374 
    (2, TType.I64, 'inventory', None, None, ), # 2
18375 
  )
18376 
 
18377 
  def __init__(self, itemId=None, inventory=None,):
18378 
    self.itemId = itemId
18379 
    self.inventory = inventory
18380 
 
18381 
  def read(self, iprot):
18382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18384 
      return
18385 
    iprot.readStructBegin()
18386 
    while True:
18387 
      (fname, ftype, fid) = iprot.readFieldBegin()
18388 
      if ftype == TType.STOP:
18389 
        break
18390 
      if fid == 1:
18391 
        if ftype == TType.I64:
18392 
          self.itemId = iprot.readI64();
18393 
        else:
18394 
          iprot.skip(ftype)
18395 
      elif fid == 2:
18396 
        if ftype == TType.I64:
18397 
          self.inventory = iprot.readI64();
18398 
        else:
18399 
          iprot.skip(ftype)
18400 
      else:
18401 
        iprot.skip(ftype)
18402 
      iprot.readFieldEnd()
18403 
    iprot.readStructEnd()
18404 
 
18405 
  def write(self, oprot):
18406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18408 
      return
18409 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
18410 
    if self.itemId is not None:
18411 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18412 
      oprot.writeI64(self.itemId)
18413 
      oprot.writeFieldEnd()
18414 
    if self.inventory is not None:
18415 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
18416 
      oprot.writeI64(self.inventory)
18417 
      oprot.writeFieldEnd()
18418 
    oprot.writeFieldStop()
18419 
    oprot.writeStructEnd()
18420 
 
18421 
  def validate(self):
18422 
    return
18423 
 
18424 
 
18425 
  def __repr__(self):
18426 
    L = ['%s=%r' % (key, value)
18427 
      for key, value in self.__dict__.iteritems()]
18428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18429 
 
18430 
  def __eq__(self, other):
18431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18432 
 
18433 
  def __ne__(self, other):
18434 
    return not (self == other)
18435 
 
18436 
class acceptOrdersForItemId_result:
18437 
  """
18438 
  Attributes:
18439 
   - success
18440 
   - ex
18441 
  """
18442 
 
18443 
  thrift_spec = (
18444 
    (0, TType.BOOL, 'success', None, None, ), # 0
18445 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18446 
  )
18447 
 
18448 
  def __init__(self, success=None, ex=None,):
18449 
    self.success = success
18450 
    self.ex = ex
18451 
 
18452 
  def read(self, iprot):
18453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18455 
      return
18456 
    iprot.readStructBegin()
18457 
    while True:
18458 
      (fname, ftype, fid) = iprot.readFieldBegin()
18459 
      if ftype == TType.STOP:
18460 
        break
18461 
      if fid == 0:
18462 
        if ftype == TType.BOOL:
18463 
          self.success = iprot.readBool();
18464 
        else:
18465 
          iprot.skip(ftype)
18466 
      elif fid == 1:
18467 
        if ftype == TType.STRUCT:
18468 
          self.ex = TransactionServiceException()
18469 
          self.ex.read(iprot)
18470 
        else:
18471 
          iprot.skip(ftype)
18472 
      else:
18473 
        iprot.skip(ftype)
18474 
      iprot.readFieldEnd()
18475 
    iprot.readStructEnd()
18476 
 
18477 
  def write(self, oprot):
18478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18480 
      return
18481 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
18482 
    if self.success is not None:
18483 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18484 
      oprot.writeBool(self.success)
18485 
      oprot.writeFieldEnd()
18486 
    if self.ex is not None:
18487 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18488 
      self.ex.write(oprot)
18489 
      oprot.writeFieldEnd()
18490 
    oprot.writeFieldStop()
18491 
    oprot.writeStructEnd()
18492 
 
18493 
  def validate(self):
18494 
    return
18495 
 
18496 
 
18497 
  def __repr__(self):
18498 
    L = ['%s=%r' % (key, value)
18499 
      for key, value in self.__dict__.iteritems()]
18500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18501 
 
18502 
  def __eq__(self, other):
18503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18504 
 
18505 
  def __ne__(self, other):
18506 
    return not (self == other)
4303 rajveer 18507 
 
18508 
class markOrdersAsPORaised_args:
18509 
  """
18510 
  Attributes:
18511 
   - vendorId
18512 
   - itemId
18513 
   - quantity
18514 
   - estimate
4369 rajveer 18515 
   - isReminder
4303 rajveer 18516 
  """
18517 
 
18518 
  thrift_spec = (
18519 
    None, # 0
18520 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18521 
    (2, TType.I64, 'itemId', None, None, ), # 2
18522 
    (3, TType.I64, 'quantity', None, None, ), # 3
18523 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18524 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18525 
  )
18526 
 
4369 rajveer 18527 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18528 
    self.vendorId = vendorId
18529 
    self.itemId = itemId
18530 
    self.quantity = quantity
18531 
    self.estimate = estimate
4369 rajveer 18532 
    self.isReminder = isReminder
4303 rajveer 18533 
 
18534 
  def read(self, iprot):
18535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18537 
      return
18538 
    iprot.readStructBegin()
18539 
    while True:
18540 
      (fname, ftype, fid) = iprot.readFieldBegin()
18541 
      if ftype == TType.STOP:
18542 
        break
18543 
      if fid == 1:
18544 
        if ftype == TType.I64:
18545 
          self.vendorId = iprot.readI64();
18546 
        else:
18547 
          iprot.skip(ftype)
18548 
      elif fid == 2:
18549 
        if ftype == TType.I64:
18550 
          self.itemId = iprot.readI64();
18551 
        else:
18552 
          iprot.skip(ftype)
18553 
      elif fid == 3:
18554 
        if ftype == TType.I64:
18555 
          self.quantity = iprot.readI64();
18556 
        else:
18557 
          iprot.skip(ftype)
18558 
      elif fid == 4:
18559 
        if ftype == TType.I64:
18560 
          self.estimate = iprot.readI64();
18561 
        else:
18562 
          iprot.skip(ftype)
4369 rajveer 18563 
      elif fid == 5:
18564 
        if ftype == TType.BOOL:
18565 
          self.isReminder = iprot.readBool();
18566 
        else:
18567 
          iprot.skip(ftype)
4303 rajveer 18568 
      else:
18569 
        iprot.skip(ftype)
18570 
      iprot.readFieldEnd()
18571 
    iprot.readStructEnd()
18572 
 
18573 
  def write(self, oprot):
18574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18576 
      return
18577 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
18578 
    if self.vendorId is not None:
18579 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18580 
      oprot.writeI64(self.vendorId)
18581 
      oprot.writeFieldEnd()
18582 
    if self.itemId is not None:
18583 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18584 
      oprot.writeI64(self.itemId)
18585 
      oprot.writeFieldEnd()
18586 
    if self.quantity is not None:
18587 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18588 
      oprot.writeI64(self.quantity)
18589 
      oprot.writeFieldEnd()
18590 
    if self.estimate is not None:
18591 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18592 
      oprot.writeI64(self.estimate)
18593 
      oprot.writeFieldEnd()
4369 rajveer 18594 
    if self.isReminder is not None:
18595 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18596 
      oprot.writeBool(self.isReminder)
18597 
      oprot.writeFieldEnd()
4303 rajveer 18598 
    oprot.writeFieldStop()
18599 
    oprot.writeStructEnd()
18600 
 
18601 
  def validate(self):
18602 
    return
18603 
 
18604 
 
18605 
  def __repr__(self):
18606 
    L = ['%s=%r' % (key, value)
18607 
      for key, value in self.__dict__.iteritems()]
18608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18609 
 
18610 
  def __eq__(self, other):
18611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18612 
 
18613 
  def __ne__(self, other):
18614 
    return not (self == other)
18615 
 
18616 
class markOrdersAsPORaised_result:
18617 
  """
18618 
  Attributes:
18619 
   - ex
18620 
  """
18621 
 
18622 
  thrift_spec = (
18623 
    None, # 0
18624 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18625 
  )
18626 
 
18627 
  def __init__(self, ex=None,):
18628 
    self.ex = ex
18629 
 
18630 
  def read(self, iprot):
18631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18633 
      return
18634 
    iprot.readStructBegin()
18635 
    while True:
18636 
      (fname, ftype, fid) = iprot.readFieldBegin()
18637 
      if ftype == TType.STOP:
18638 
        break
18639 
      if fid == 1:
18640 
        if ftype == TType.STRUCT:
18641 
          self.ex = TransactionServiceException()
18642 
          self.ex.read(iprot)
18643 
        else:
18644 
          iprot.skip(ftype)
18645 
      else:
18646 
        iprot.skip(ftype)
18647 
      iprot.readFieldEnd()
18648 
    iprot.readStructEnd()
18649 
 
18650 
  def write(self, oprot):
18651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18653 
      return
18654 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
18655 
    if self.ex is not None:
18656 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18657 
      self.ex.write(oprot)
18658 
      oprot.writeFieldEnd()
18659 
    oprot.writeFieldStop()
18660 
    oprot.writeStructEnd()
18661 
 
18662 
  def validate(self):
18663 
    return
18664 
 
18665 
 
18666 
  def __repr__(self):
18667 
    L = ['%s=%r' % (key, value)
18668 
      for key, value in self.__dict__.iteritems()]
18669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18670 
 
18671 
  def __eq__(self, other):
18672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18673 
 
18674 
  def __ne__(self, other):
18675 
    return not (self == other)
18676 
 
18677 
class markOrdersAsReversalInitiated_args:
18678 
  """
18679 
  Attributes:
18680 
   - vendorId
18681 
   - itemId
18682 
   - quantity
18683 
   - estimate
4369 rajveer 18684 
   - isReminder
4303 rajveer 18685 
  """
18686 
 
18687 
  thrift_spec = (
18688 
    None, # 0
18689 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18690 
    (2, TType.I64, 'itemId', None, None, ), # 2
18691 
    (3, TType.I64, 'quantity', None, None, ), # 3
18692 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18693 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18694 
  )
18695 
 
4369 rajveer 18696 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18697 
    self.vendorId = vendorId
18698 
    self.itemId = itemId
18699 
    self.quantity = quantity
18700 
    self.estimate = estimate
4369 rajveer 18701 
    self.isReminder = isReminder
4303 rajveer 18702 
 
18703 
  def read(self, iprot):
18704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18706 
      return
18707 
    iprot.readStructBegin()
18708 
    while True:
18709 
      (fname, ftype, fid) = iprot.readFieldBegin()
18710 
      if ftype == TType.STOP:
18711 
        break
18712 
      if fid == 1:
18713 
        if ftype == TType.I64:
18714 
          self.vendorId = iprot.readI64();
18715 
        else:
18716 
          iprot.skip(ftype)
18717 
      elif fid == 2:
18718 
        if ftype == TType.I64:
18719 
          self.itemId = iprot.readI64();
18720 
        else:
18721 
          iprot.skip(ftype)
18722 
      elif fid == 3:
18723 
        if ftype == TType.I64:
18724 
          self.quantity = iprot.readI64();
18725 
        else:
18726 
          iprot.skip(ftype)
18727 
      elif fid == 4:
18728 
        if ftype == TType.I64:
18729 
          self.estimate = iprot.readI64();
18730 
        else:
18731 
          iprot.skip(ftype)
4369 rajveer 18732 
      elif fid == 5:
18733 
        if ftype == TType.BOOL:
18734 
          self.isReminder = iprot.readBool();
18735 
        else:
18736 
          iprot.skip(ftype)
4303 rajveer 18737 
      else:
18738 
        iprot.skip(ftype)
18739 
      iprot.readFieldEnd()
18740 
    iprot.readStructEnd()
18741 
 
18742 
  def write(self, oprot):
18743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18745 
      return
18746 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
18747 
    if self.vendorId is not None:
18748 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18749 
      oprot.writeI64(self.vendorId)
18750 
      oprot.writeFieldEnd()
18751 
    if self.itemId is not None:
18752 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18753 
      oprot.writeI64(self.itemId)
18754 
      oprot.writeFieldEnd()
18755 
    if self.quantity is not None:
18756 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18757 
      oprot.writeI64(self.quantity)
18758 
      oprot.writeFieldEnd()
18759 
    if self.estimate is not None:
18760 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18761 
      oprot.writeI64(self.estimate)
18762 
      oprot.writeFieldEnd()
4369 rajveer 18763 
    if self.isReminder is not None:
18764 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18765 
      oprot.writeBool(self.isReminder)
18766 
      oprot.writeFieldEnd()
4303 rajveer 18767 
    oprot.writeFieldStop()
18768 
    oprot.writeStructEnd()
18769 
 
18770 
  def validate(self):
18771 
    return
18772 
 
18773 
 
18774 
  def __repr__(self):
18775 
    L = ['%s=%r' % (key, value)
18776 
      for key, value in self.__dict__.iteritems()]
18777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18778 
 
18779 
  def __eq__(self, other):
18780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18781 
 
18782 
  def __ne__(self, other):
18783 
    return not (self == other)
18784 
 
18785 
class markOrdersAsReversalInitiated_result:
18786 
  """
18787 
  Attributes:
18788 
   - ex
18789 
  """
18790 
 
18791 
  thrift_spec = (
18792 
    None, # 0
18793 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18794 
  )
18795 
 
18796 
  def __init__(self, ex=None,):
18797 
    self.ex = ex
18798 
 
18799 
  def read(self, iprot):
18800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18802 
      return
18803 
    iprot.readStructBegin()
18804 
    while True:
18805 
      (fname, ftype, fid) = iprot.readFieldBegin()
18806 
      if ftype == TType.STOP:
18807 
        break
18808 
      if fid == 1:
18809 
        if ftype == TType.STRUCT:
18810 
          self.ex = TransactionServiceException()
18811 
          self.ex.read(iprot)
18812 
        else:
18813 
          iprot.skip(ftype)
18814 
      else:
18815 
        iprot.skip(ftype)
18816 
      iprot.readFieldEnd()
18817 
    iprot.readStructEnd()
18818 
 
18819 
  def write(self, oprot):
18820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18822 
      return
18823 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
18824 
    if self.ex is not None:
18825 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18826 
      self.ex.write(oprot)
18827 
      oprot.writeFieldEnd()
18828 
    oprot.writeFieldStop()
18829 
    oprot.writeStructEnd()
18830 
 
18831 
  def validate(self):
18832 
    return
18833 
 
18834 
 
18835 
  def __repr__(self):
18836 
    L = ['%s=%r' % (key, value)
18837 
      for key, value in self.__dict__.iteritems()]
18838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18839 
 
18840 
  def __eq__(self, other):
18841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18842 
 
18843 
  def __ne__(self, other):
18844 
    return not (self == other)
18845 
 
18846 
class markOrdersAsNotAvailabke_args:
18847 
  """
18848 
  Attributes:
18849 
   - vendorId
18850 
   - itemId
18851 
   - quantity
18852 
   - estimate
4369 rajveer 18853 
   - isReminder
4303 rajveer 18854 
  """
18855 
 
18856 
  thrift_spec = (
18857 
    None, # 0
18858 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18859 
    (2, TType.I64, 'itemId', None, None, ), # 2
18860 
    (3, TType.I64, 'quantity', None, None, ), # 3
18861 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18862 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18863 
  )
18864 
 
4369 rajveer 18865 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18866 
    self.vendorId = vendorId
18867 
    self.itemId = itemId
18868 
    self.quantity = quantity
18869 
    self.estimate = estimate
4369 rajveer 18870 
    self.isReminder = isReminder
4303 rajveer 18871 
 
18872 
  def read(self, iprot):
18873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18875 
      return
18876 
    iprot.readStructBegin()
18877 
    while True:
18878 
      (fname, ftype, fid) = iprot.readFieldBegin()
18879 
      if ftype == TType.STOP:
18880 
        break
18881 
      if fid == 1:
18882 
        if ftype == TType.I64:
18883 
          self.vendorId = iprot.readI64();
18884 
        else:
18885 
          iprot.skip(ftype)
18886 
      elif fid == 2:
18887 
        if ftype == TType.I64:
18888 
          self.itemId = iprot.readI64();
18889 
        else:
18890 
          iprot.skip(ftype)
18891 
      elif fid == 3:
18892 
        if ftype == TType.I64:
18893 
          self.quantity = iprot.readI64();
18894 
        else:
18895 
          iprot.skip(ftype)
18896 
      elif fid == 4:
18897 
        if ftype == TType.I64:
18898 
          self.estimate = iprot.readI64();
18899 
        else:
18900 
          iprot.skip(ftype)
4369 rajveer 18901 
      elif fid == 5:
18902 
        if ftype == TType.BOOL:
18903 
          self.isReminder = iprot.readBool();
18904 
        else:
18905 
          iprot.skip(ftype)
4303 rajveer 18906 
      else:
18907 
        iprot.skip(ftype)
18908 
      iprot.readFieldEnd()
18909 
    iprot.readStructEnd()
18910 
 
18911 
  def write(self, oprot):
18912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18914 
      return
18915 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
18916 
    if self.vendorId is not None:
18917 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18918 
      oprot.writeI64(self.vendorId)
18919 
      oprot.writeFieldEnd()
18920 
    if self.itemId is not None:
18921 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18922 
      oprot.writeI64(self.itemId)
18923 
      oprot.writeFieldEnd()
18924 
    if self.quantity is not None:
18925 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18926 
      oprot.writeI64(self.quantity)
18927 
      oprot.writeFieldEnd()
18928 
    if self.estimate is not None:
18929 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18930 
      oprot.writeI64(self.estimate)
18931 
      oprot.writeFieldEnd()
4369 rajveer 18932 
    if self.isReminder is not None:
18933 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18934 
      oprot.writeBool(self.isReminder)
18935 
      oprot.writeFieldEnd()
4303 rajveer 18936 
    oprot.writeFieldStop()
18937 
    oprot.writeStructEnd()
18938 
 
18939 
  def validate(self):
18940 
    return
18941 
 
18942 
 
18943 
  def __repr__(self):
18944 
    L = ['%s=%r' % (key, value)
18945 
      for key, value in self.__dict__.iteritems()]
18946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18947 
 
18948 
  def __eq__(self, other):
18949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18950 
 
18951 
  def __ne__(self, other):
18952 
    return not (self == other)
18953 
 
18954 
class markOrdersAsNotAvailabke_result:
18955 
  """
18956 
  Attributes:
18957 
   - ex
18958 
  """
18959 
 
18960 
  thrift_spec = (
18961 
    None, # 0
18962 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18963 
  )
18964 
 
18965 
  def __init__(self, ex=None,):
18966 
    self.ex = ex
18967 
 
18968 
  def read(self, iprot):
18969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18971 
      return
18972 
    iprot.readStructBegin()
18973 
    while True:
18974 
      (fname, ftype, fid) = iprot.readFieldBegin()
18975 
      if ftype == TType.STOP:
18976 
        break
18977 
      if fid == 1:
18978 
        if ftype == TType.STRUCT:
18979 
          self.ex = TransactionServiceException()
18980 
          self.ex.read(iprot)
18981 
        else:
18982 
          iprot.skip(ftype)
18983 
      else:
18984 
        iprot.skip(ftype)
18985 
      iprot.readFieldEnd()
18986 
    iprot.readStructEnd()
18987 
 
18988 
  def write(self, oprot):
18989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18991 
      return
18992 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
18993 
    if self.ex is not None:
18994 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18995 
      self.ex.write(oprot)
18996 
      oprot.writeFieldEnd()
18997 
    oprot.writeFieldStop()
18998 
    oprot.writeStructEnd()
18999 
 
19000 
  def validate(self):
19001 
    return
19002 
 
19003 
 
19004 
  def __repr__(self):
19005 
    L = ['%s=%r' % (key, value)
19006 
      for key, value in self.__dict__.iteritems()]
19007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19008 
 
19009 
  def __eq__(self, other):
19010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19011 
 
19012 
  def __ne__(self, other):
19013 
    return not (self == other)
4369 rajveer 19014 
 
19015 
class markOrdersAsTimeout_args:
19016 
  """
19017 
  Attributes:
19018 
   - vendorId
19019 
  """
19020 
 
19021 
  thrift_spec = (
19022 
    None, # 0
19023 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19024 
  )
19025 
 
19026 
  def __init__(self, vendorId=None,):
19027 
    self.vendorId = vendorId
19028 
 
19029 
  def read(self, iprot):
19030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19032 
      return
19033 
    iprot.readStructBegin()
19034 
    while True:
19035 
      (fname, ftype, fid) = iprot.readFieldBegin()
19036 
      if ftype == TType.STOP:
19037 
        break
19038 
      if fid == 1:
19039 
        if ftype == TType.I64:
19040 
          self.vendorId = iprot.readI64();
19041 
        else:
19042 
          iprot.skip(ftype)
19043 
      else:
19044 
        iprot.skip(ftype)
19045 
      iprot.readFieldEnd()
19046 
    iprot.readStructEnd()
19047 
 
19048 
  def write(self, oprot):
19049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19051 
      return
19052 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
19053 
    if self.vendorId is not None:
19054 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19055 
      oprot.writeI64(self.vendorId)
19056 
      oprot.writeFieldEnd()
19057 
    oprot.writeFieldStop()
19058 
    oprot.writeStructEnd()
19059 
 
19060 
  def validate(self):
19061 
    return
19062 
 
19063 
 
19064 
  def __repr__(self):
19065 
    L = ['%s=%r' % (key, value)
19066 
      for key, value in self.__dict__.iteritems()]
19067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19068 
 
19069 
  def __eq__(self, other):
19070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19071 
 
19072 
  def __ne__(self, other):
19073 
    return not (self == other)
19074 
 
19075 
class markOrdersAsTimeout_result:
19076 
  """
19077 
  Attributes:
19078 
   - success
19079 
   - ex
19080 
  """
19081 
 
19082 
  thrift_spec = (
19083 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
19084 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19085 
  )
19086 
 
19087 
  def __init__(self, success=None, ex=None,):
19088 
    self.success = success
19089 
    self.ex = ex
19090 
 
19091 
  def read(self, iprot):
19092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19094 
      return
19095 
    iprot.readStructBegin()
19096 
    while True:
19097 
      (fname, ftype, fid) = iprot.readFieldBegin()
19098 
      if ftype == TType.STOP:
19099 
        break
19100 
      if fid == 0:
19101 
        if ftype == TType.MAP:
19102 
          self.success = {}
5031 varun.gupt 19103 
          (_ktype410, _vtype411, _size409 ) = iprot.readMapBegin()
19104 
          for _i413 in xrange(_size409):
19105 
            _key414 = iprot.readI32();
19106 
            _val415 = TimeoutSummary()
19107 
            _val415.read(iprot)
19108 
            self.success[_key414] = _val415
4369 rajveer 19109 
          iprot.readMapEnd()
19110 
        else:
19111 
          iprot.skip(ftype)
19112 
      elif fid == 1:
19113 
        if ftype == TType.STRUCT:
19114 
          self.ex = TransactionServiceException()
19115 
          self.ex.read(iprot)
19116 
        else:
19117 
          iprot.skip(ftype)
19118 
      else:
19119 
        iprot.skip(ftype)
19120 
      iprot.readFieldEnd()
19121 
    iprot.readStructEnd()
19122 
 
19123 
  def write(self, oprot):
19124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19126 
      return
19127 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
19128 
    if self.success is not None:
19129 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19130 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
5031 varun.gupt 19131 
      for kiter416,viter417 in self.success.items():
19132 
        oprot.writeI32(kiter416)
19133 
        viter417.write(oprot)
4369 rajveer 19134 
      oprot.writeMapEnd()
19135 
      oprot.writeFieldEnd()
19136 
    if self.ex is not None:
19137 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19138 
      self.ex.write(oprot)
19139 
      oprot.writeFieldEnd()
19140 
    oprot.writeFieldStop()
19141 
    oprot.writeStructEnd()
19142 
 
19143 
  def validate(self):
19144 
    return
19145 
 
19146 
 
19147 
  def __repr__(self):
19148 
    L = ['%s=%r' % (key, value)
19149 
      for key, value in self.__dict__.iteritems()]
19150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19151 
 
19152 
  def __eq__(self, other):
19153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19154 
 
19155 
  def __ne__(self, other):
19156 
    return not (self == other)
4386 anupam.sin 19157 
 
4662 rajveer 19158 
class markOrderAsLostInTransit_args:
19159 
  """
19160 
  Attributes:
19161 
   - orderId
19162 
  """
19163 
 
19164 
  thrift_spec = (
19165 
    None, # 0
19166 
    (1, TType.I64, 'orderId', None, None, ), # 1
19167 
  )
19168 
 
19169 
  def __init__(self, orderId=None,):
19170 
    self.orderId = orderId
19171 
 
19172 
  def read(self, iprot):
19173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19175 
      return
19176 
    iprot.readStructBegin()
19177 
    while True:
19178 
      (fname, ftype, fid) = iprot.readFieldBegin()
19179 
      if ftype == TType.STOP:
19180 
        break
19181 
      if fid == 1:
19182 
        if ftype == TType.I64:
19183 
          self.orderId = iprot.readI64();
19184 
        else:
19185 
          iprot.skip(ftype)
19186 
      else:
19187 
        iprot.skip(ftype)
19188 
      iprot.readFieldEnd()
19189 
    iprot.readStructEnd()
19190 
 
19191 
  def write(self, oprot):
19192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19194 
      return
19195 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
19196 
    if self.orderId is not None:
19197 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19198 
      oprot.writeI64(self.orderId)
19199 
      oprot.writeFieldEnd()
19200 
    oprot.writeFieldStop()
19201 
    oprot.writeStructEnd()
19202 
 
19203 
  def validate(self):
19204 
    return
19205 
 
19206 
 
19207 
  def __repr__(self):
19208 
    L = ['%s=%r' % (key, value)
19209 
      for key, value in self.__dict__.iteritems()]
19210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19211 
 
19212 
  def __eq__(self, other):
19213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19214 
 
19215 
  def __ne__(self, other):
19216 
    return not (self == other)
19217 
 
19218 
class markOrderAsLostInTransit_result:
19219 
  """
19220 
  Attributes:
19221 
   - success
19222 
   - ex
19223 
  """
19224 
 
19225 
  thrift_spec = (
19226 
    (0, TType.BOOL, 'success', None, None, ), # 0
19227 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19228 
  )
19229 
 
19230 
  def __init__(self, success=None, ex=None,):
19231 
    self.success = success
19232 
    self.ex = ex
19233 
 
19234 
  def read(self, iprot):
19235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19237 
      return
19238 
    iprot.readStructBegin()
19239 
    while True:
19240 
      (fname, ftype, fid) = iprot.readFieldBegin()
19241 
      if ftype == TType.STOP:
19242 
        break
19243 
      if fid == 0:
19244 
        if ftype == TType.BOOL:
19245 
          self.success = iprot.readBool();
19246 
        else:
19247 
          iprot.skip(ftype)
19248 
      elif fid == 1:
19249 
        if ftype == TType.STRUCT:
19250 
          self.ex = TransactionServiceException()
19251 
          self.ex.read(iprot)
19252 
        else:
19253 
          iprot.skip(ftype)
19254 
      else:
19255 
        iprot.skip(ftype)
19256 
      iprot.readFieldEnd()
19257 
    iprot.readStructEnd()
19258 
 
19259 
  def write(self, oprot):
19260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19262 
      return
19263 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
19264 
    if self.success is not None:
19265 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19266 
      oprot.writeBool(self.success)
19267 
      oprot.writeFieldEnd()
19268 
    if self.ex is not None:
19269 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19270 
      self.ex.write(oprot)
19271 
      oprot.writeFieldEnd()
19272 
    oprot.writeFieldStop()
19273 
    oprot.writeStructEnd()
19274 
 
19275 
  def validate(self):
19276 
    return
19277 
 
19278 
 
19279 
  def __repr__(self):
19280 
    L = ['%s=%r' % (key, value)
19281 
      for key, value in self.__dict__.iteritems()]
19282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19283 
 
19284 
  def __eq__(self, other):
19285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19286 
 
19287 
  def __ne__(self, other):
19288 
    return not (self == other)
19289 
 
4386 anupam.sin 19290 
class getOrderForAwb_args:
19291 
  """
19292 
  Attributes:
19293 
   - awb
19294 
  """
19295 
 
19296 
  thrift_spec = (
19297 
    None, # 0
19298 
    (1, TType.STRING, 'awb', None, None, ), # 1
19299 
  )
19300 
 
19301 
  def __init__(self, awb=None,):
19302 
    self.awb = awb
19303 
 
19304 
  def read(self, iprot):
19305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19307 
      return
19308 
    iprot.readStructBegin()
19309 
    while True:
19310 
      (fname, ftype, fid) = iprot.readFieldBegin()
19311 
      if ftype == TType.STOP:
19312 
        break
19313 
      if fid == 1:
19314 
        if ftype == TType.STRING:
19315 
          self.awb = iprot.readString();
19316 
        else:
19317 
          iprot.skip(ftype)
19318 
      else:
19319 
        iprot.skip(ftype)
19320 
      iprot.readFieldEnd()
19321 
    iprot.readStructEnd()
19322 
 
19323 
  def write(self, oprot):
19324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19326 
      return
19327 
    oprot.writeStructBegin('getOrderForAwb_args')
19328 
    if self.awb is not None:
19329 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
19330 
      oprot.writeString(self.awb)
19331 
      oprot.writeFieldEnd()
19332 
    oprot.writeFieldStop()
19333 
    oprot.writeStructEnd()
19334 
 
19335 
  def validate(self):
19336 
    return
19337 
 
19338 
 
19339 
  def __repr__(self):
19340 
    L = ['%s=%r' % (key, value)
19341 
      for key, value in self.__dict__.iteritems()]
19342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19343 
 
19344 
  def __eq__(self, other):
19345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19346 
 
19347 
  def __ne__(self, other):
19348 
    return not (self == other)
19349 
 
19350 
class getOrderForAwb_result:
19351 
  """
19352 
  Attributes:
19353 
   - success
19354 
   - ex
19355 
  """
19356 
 
19357 
  thrift_spec = (
19358 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19359 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19360 
  )
19361 
 
19362 
  def __init__(self, success=None, ex=None,):
19363 
    self.success = success
19364 
    self.ex = ex
19365 
 
19366 
  def read(self, iprot):
19367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19369 
      return
19370 
    iprot.readStructBegin()
19371 
    while True:
19372 
      (fname, ftype, fid) = iprot.readFieldBegin()
19373 
      if ftype == TType.STOP:
19374 
        break
19375 
      if fid == 0:
19376 
        if ftype == TType.STRUCT:
19377 
          self.success = Order()
19378 
          self.success.read(iprot)
19379 
        else:
19380 
          iprot.skip(ftype)
19381 
      elif fid == 1:
19382 
        if ftype == TType.STRUCT:
19383 
          self.ex = TransactionServiceException()
19384 
          self.ex.read(iprot)
19385 
        else:
19386 
          iprot.skip(ftype)
19387 
      else:
19388 
        iprot.skip(ftype)
19389 
      iprot.readFieldEnd()
19390 
    iprot.readStructEnd()
19391 
 
19392 
  def write(self, oprot):
19393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19395 
      return
19396 
    oprot.writeStructBegin('getOrderForAwb_result')
19397 
    if self.success is not None:
19398 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19399 
      self.success.write(oprot)
19400 
      oprot.writeFieldEnd()
19401 
    if self.ex is not None:
19402 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19403 
      self.ex.write(oprot)
19404 
      oprot.writeFieldEnd()
19405 
    oprot.writeFieldStop()
19406 
    oprot.writeStructEnd()
19407 
 
19408 
  def validate(self):
19409 
    return
19410 
 
19411 
 
19412 
  def __repr__(self):
19413 
    L = ['%s=%r' % (key, value)
19414 
      for key, value in self.__dict__.iteritems()]
19415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19416 
 
19417 
  def __eq__(self, other):
19418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19419 
 
19420 
  def __ne__(self, other):
19421 
    return not (self == other)
4506 phani.kuma 19422 
 
19423 
class getOrdersForProviderForStatus_args:
19424 
  """
19425 
  Attributes:
19426 
   - logistics_provider_id
4910 phani.kuma 19427 
   - order_status_list
4506 phani.kuma 19428 
  """
19429 
 
19430 
  thrift_spec = (
19431 
    None, # 0
19432 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 19433 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 19434 
  )
19435 
 
4910 phani.kuma 19436 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 19437 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 19438 
    self.order_status_list = order_status_list
4506 phani.kuma 19439 
 
19440 
  def read(self, iprot):
19441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19443 
      return
19444 
    iprot.readStructBegin()
19445 
    while True:
19446 
      (fname, ftype, fid) = iprot.readFieldBegin()
19447 
      if ftype == TType.STOP:
19448 
        break
19449 
      if fid == 1:
19450 
        if ftype == TType.I64:
19451 
          self.logistics_provider_id = iprot.readI64();
19452 
        else:
19453 
          iprot.skip(ftype)
19454 
      elif fid == 2:
4910 phani.kuma 19455 
        if ftype == TType.LIST:
19456 
          self.order_status_list = []
5031 varun.gupt 19457 
          (_etype421, _size418) = iprot.readListBegin()
19458 
          for _i422 in xrange(_size418):
19459 
            _elem423 = iprot.readI32();
19460 
            self.order_status_list.append(_elem423)
4910 phani.kuma 19461 
          iprot.readListEnd()
4506 phani.kuma 19462 
        else:
19463 
          iprot.skip(ftype)
19464 
      else:
19465 
        iprot.skip(ftype)
19466 
      iprot.readFieldEnd()
19467 
    iprot.readStructEnd()
19468 
 
19469 
  def write(self, oprot):
19470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19472 
      return
19473 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
19474 
    if self.logistics_provider_id is not None:
19475 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
19476 
      oprot.writeI64(self.logistics_provider_id)
19477 
      oprot.writeFieldEnd()
4910 phani.kuma 19478 
    if self.order_status_list is not None:
19479 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
19480 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
5031 varun.gupt 19481 
      for iter424 in self.order_status_list:
19482 
        oprot.writeI32(iter424)
4910 phani.kuma 19483 
      oprot.writeListEnd()
4506 phani.kuma 19484 
      oprot.writeFieldEnd()
19485 
    oprot.writeFieldStop()
19486 
    oprot.writeStructEnd()
19487 
 
19488 
  def validate(self):
19489 
    return
19490 
 
19491 
 
19492 
  def __repr__(self):
19493 
    L = ['%s=%r' % (key, value)
19494 
      for key, value in self.__dict__.iteritems()]
19495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19496 
 
19497 
  def __eq__(self, other):
19498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19499 
 
19500 
  def __ne__(self, other):
19501 
    return not (self == other)
19502 
 
19503 
class getOrdersForProviderForStatus_result:
19504 
  """
19505 
  Attributes:
19506 
   - success
19507 
   - ex
19508 
  """
19509 
 
19510 
  thrift_spec = (
19511 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19512 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19513 
  )
19514 
 
19515 
  def __init__(self, success=None, ex=None,):
19516 
    self.success = success
19517 
    self.ex = ex
19518 
 
19519 
  def read(self, iprot):
19520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19522 
      return
19523 
    iprot.readStructBegin()
19524 
    while True:
19525 
      (fname, ftype, fid) = iprot.readFieldBegin()
19526 
      if ftype == TType.STOP:
19527 
        break
19528 
      if fid == 0:
19529 
        if ftype == TType.LIST:
19530 
          self.success = []
5031 varun.gupt 19531 
          (_etype428, _size425) = iprot.readListBegin()
19532 
          for _i429 in xrange(_size425):
19533 
            _elem430 = Order()
19534 
            _elem430.read(iprot)
19535 
            self.success.append(_elem430)
4506 phani.kuma 19536 
          iprot.readListEnd()
19537 
        else:
19538 
          iprot.skip(ftype)
19539 
      elif fid == 1:
19540 
        if ftype == TType.STRUCT:
19541 
          self.ex = TransactionServiceException()
19542 
          self.ex.read(iprot)
19543 
        else:
19544 
          iprot.skip(ftype)
19545 
      else:
19546 
        iprot.skip(ftype)
19547 
      iprot.readFieldEnd()
19548 
    iprot.readStructEnd()
19549 
 
19550 
  def write(self, oprot):
19551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19553 
      return
19554 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
19555 
    if self.success is not None:
19556 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19557 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19558 
      for iter431 in self.success:
19559 
        iter431.write(oprot)
4506 phani.kuma 19560 
      oprot.writeListEnd()
19561 
      oprot.writeFieldEnd()
19562 
    if self.ex is not None:
19563 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19564 
      self.ex.write(oprot)
19565 
      oprot.writeFieldEnd()
19566 
    oprot.writeFieldStop()
19567 
    oprot.writeStructEnd()
19568 
 
19569 
  def validate(self):
19570 
    return
19571 
 
19572 
 
19573 
  def __repr__(self):
19574 
    L = ['%s=%r' % (key, value)
19575 
      for key, value in self.__dict__.iteritems()]
19576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19577 
 
19578 
  def __eq__(self, other):
19579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19580 
 
19581 
  def __ne__(self, other):
19582 
    return not (self == other)
4600 varun.gupt 19583 
 
19584 
class getBilledOrdersForVendor_args:
19585 
  """
19586 
  Attributes:
19587 
   - vendorId
19588 
   - billingDateFrom
19589 
   - billingDateTo
19590 
  """
19591 
 
19592 
  thrift_spec = (
19593 
    None, # 0
19594 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19595 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
19596 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
19597 
  )
19598 
 
19599 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
19600 
    self.vendorId = vendorId
19601 
    self.billingDateFrom = billingDateFrom
19602 
    self.billingDateTo = billingDateTo
19603 
 
19604 
  def read(self, iprot):
19605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19607 
      return
19608 
    iprot.readStructBegin()
19609 
    while True:
19610 
      (fname, ftype, fid) = iprot.readFieldBegin()
19611 
      if ftype == TType.STOP:
19612 
        break
19613 
      if fid == 1:
19614 
        if ftype == TType.I64:
19615 
          self.vendorId = iprot.readI64();
19616 
        else:
19617 
          iprot.skip(ftype)
19618 
      elif fid == 2:
19619 
        if ftype == TType.I64:
19620 
          self.billingDateFrom = iprot.readI64();
19621 
        else:
19622 
          iprot.skip(ftype)
19623 
      elif fid == 3:
19624 
        if ftype == TType.I64:
19625 
          self.billingDateTo = iprot.readI64();
19626 
        else:
19627 
          iprot.skip(ftype)
19628 
      else:
19629 
        iprot.skip(ftype)
19630 
      iprot.readFieldEnd()
19631 
    iprot.readStructEnd()
19632 
 
19633 
  def write(self, oprot):
19634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19636 
      return
19637 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
19638 
    if self.vendorId is not None:
19639 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19640 
      oprot.writeI64(self.vendorId)
19641 
      oprot.writeFieldEnd()
19642 
    if self.billingDateFrom is not None:
19643 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
19644 
      oprot.writeI64(self.billingDateFrom)
19645 
      oprot.writeFieldEnd()
19646 
    if self.billingDateTo is not None:
19647 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
19648 
      oprot.writeI64(self.billingDateTo)
19649 
      oprot.writeFieldEnd()
19650 
    oprot.writeFieldStop()
19651 
    oprot.writeStructEnd()
19652 
 
19653 
  def validate(self):
19654 
    return
19655 
 
19656 
 
19657 
  def __repr__(self):
19658 
    L = ['%s=%r' % (key, value)
19659 
      for key, value in self.__dict__.iteritems()]
19660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19661 
 
19662 
  def __eq__(self, other):
19663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19664 
 
19665 
  def __ne__(self, other):
19666 
    return not (self == other)
19667 
 
19668 
class getBilledOrdersForVendor_result:
19669 
  """
19670 
  Attributes:
19671 
   - success
19672 
   - ex
19673 
  """
19674 
 
19675 
  thrift_spec = (
19676 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19677 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19678 
  )
19679 
 
19680 
  def __init__(self, success=None, ex=None,):
19681 
    self.success = success
19682 
    self.ex = ex
19683 
 
19684 
  def read(self, iprot):
19685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19687 
      return
19688 
    iprot.readStructBegin()
19689 
    while True:
19690 
      (fname, ftype, fid) = iprot.readFieldBegin()
19691 
      if ftype == TType.STOP:
19692 
        break
19693 
      if fid == 0:
19694 
        if ftype == TType.LIST:
19695 
          self.success = []
5031 varun.gupt 19696 
          (_etype435, _size432) = iprot.readListBegin()
19697 
          for _i436 in xrange(_size432):
19698 
            _elem437 = Order()
19699 
            _elem437.read(iprot)
19700 
            self.success.append(_elem437)
4600 varun.gupt 19701 
          iprot.readListEnd()
19702 
        else:
19703 
          iprot.skip(ftype)
19704 
      elif fid == 1:
19705 
        if ftype == TType.STRUCT:
19706 
          self.ex = TransactionServiceException()
19707 
          self.ex.read(iprot)
19708 
        else:
19709 
          iprot.skip(ftype)
19710 
      else:
19711 
        iprot.skip(ftype)
19712 
      iprot.readFieldEnd()
19713 
    iprot.readStructEnd()
19714 
 
19715 
  def write(self, oprot):
19716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19718 
      return
19719 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
19720 
    if self.success is not None:
19721 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19722 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19723 
      for iter438 in self.success:
19724 
        iter438.write(oprot)
4600 varun.gupt 19725 
      oprot.writeListEnd()
19726 
      oprot.writeFieldEnd()
19727 
    if self.ex is not None:
19728 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19729 
      self.ex.write(oprot)
19730 
      oprot.writeFieldEnd()
19731 
    oprot.writeFieldStop()
19732 
    oprot.writeStructEnd()
19733 
 
19734 
  def validate(self):
19735 
    return
19736 
 
19737 
 
19738 
  def __repr__(self):
19739 
    L = ['%s=%r' % (key, value)
19740 
      for key, value in self.__dict__.iteritems()]
19741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19742 
 
19743 
  def __eq__(self, other):
19744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19745 
 
19746 
  def __ne__(self, other):
19747 
    return not (self == other)
19748 
 
4607 rajveer 19749 
class getSlippedSippingDateOrders_args:
19750 
 
19751 
  thrift_spec = (
19752 
  )
19753 
 
19754 
  def read(self, iprot):
19755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19757 
      return
19758 
    iprot.readStructBegin()
19759 
    while True:
19760 
      (fname, ftype, fid) = iprot.readFieldBegin()
19761 
      if ftype == TType.STOP:
19762 
        break
19763 
      else:
19764 
        iprot.skip(ftype)
19765 
      iprot.readFieldEnd()
19766 
    iprot.readStructEnd()
19767 
 
19768 
  def write(self, oprot):
19769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19771 
      return
19772 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
19773 
    oprot.writeFieldStop()
19774 
    oprot.writeStructEnd()
19775 
 
19776 
  def validate(self):
19777 
    return
19778 
 
19779 
 
19780 
  def __repr__(self):
19781 
    L = ['%s=%r' % (key, value)
19782 
      for key, value in self.__dict__.iteritems()]
19783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19784 
 
19785 
  def __eq__(self, other):
19786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19787 
 
19788 
  def __ne__(self, other):
19789 
    return not (self == other)
19790 
 
19791 
class getSlippedSippingDateOrders_result:
19792 
  """
19793 
  Attributes:
19794 
   - success
19795 
   - ex
19796 
  """
19797 
 
19798 
  thrift_spec = (
19799 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19800 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19801 
  )
19802 
 
19803 
  def __init__(self, success=None, ex=None,):
19804 
    self.success = success
19805 
    self.ex = ex
19806 
 
19807 
  def read(self, iprot):
19808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19810 
      return
19811 
    iprot.readStructBegin()
19812 
    while True:
19813 
      (fname, ftype, fid) = iprot.readFieldBegin()
19814 
      if ftype == TType.STOP:
19815 
        break
19816 
      if fid == 0:
19817 
        if ftype == TType.LIST:
19818 
          self.success = []
5031 varun.gupt 19819 
          (_etype442, _size439) = iprot.readListBegin()
19820 
          for _i443 in xrange(_size439):
19821 
            _elem444 = Order()
19822 
            _elem444.read(iprot)
19823 
            self.success.append(_elem444)
4607 rajveer 19824 
          iprot.readListEnd()
19825 
        else:
19826 
          iprot.skip(ftype)
19827 
      elif fid == 1:
19828 
        if ftype == TType.STRUCT:
19829 
          self.ex = TransactionServiceException()
19830 
          self.ex.read(iprot)
19831 
        else:
19832 
          iprot.skip(ftype)
19833 
      else:
19834 
        iprot.skip(ftype)
19835 
      iprot.readFieldEnd()
19836 
    iprot.readStructEnd()
19837 
 
19838 
  def write(self, oprot):
19839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19841 
      return
19842 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
19843 
    if self.success is not None:
19844 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19845 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19846 
      for iter445 in self.success:
19847 
        iter445.write(oprot)
4607 rajveer 19848 
      oprot.writeListEnd()
19849 
      oprot.writeFieldEnd()
19850 
    if self.ex is not None:
19851 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19852 
      self.ex.write(oprot)
19853 
      oprot.writeFieldEnd()
19854 
    oprot.writeFieldStop()
19855 
    oprot.writeStructEnd()
19856 
 
19857 
  def validate(self):
19858 
    return
19859 
 
19860 
 
19861 
  def __repr__(self):
19862 
    L = ['%s=%r' % (key, value)
19863 
      for key, value in self.__dict__.iteritems()]
19864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19865 
 
19866 
  def __eq__(self, other):
19867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19868 
 
19869 
  def __ne__(self, other):
19870 
    return not (self == other)
19871 
 
4709 rajveer 19872 
class getCancelledOrders_args:
19873 
  """
19874 
  Attributes:
19875 
   - cancelDateFrom
19876 
   - cancelDateTo
19877 
  """
19878 
 
19879 
  thrift_spec = (
19880 
    None, # 0
19881 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
19882 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
19883 
  )
19884 
 
19885 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
19886 
    self.cancelDateFrom = cancelDateFrom
19887 
    self.cancelDateTo = cancelDateTo
19888 
 
19889 
  def read(self, iprot):
19890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19892 
      return
19893 
    iprot.readStructBegin()
19894 
    while True:
19895 
      (fname, ftype, fid) = iprot.readFieldBegin()
19896 
      if ftype == TType.STOP:
19897 
        break
19898 
      if fid == 1:
19899 
        if ftype == TType.I64:
19900 
          self.cancelDateFrom = iprot.readI64();
19901 
        else:
19902 
          iprot.skip(ftype)
19903 
      elif fid == 2:
19904 
        if ftype == TType.I64:
19905 
          self.cancelDateTo = iprot.readI64();
19906 
        else:
19907 
          iprot.skip(ftype)
19908 
      else:
19909 
        iprot.skip(ftype)
19910 
      iprot.readFieldEnd()
19911 
    iprot.readStructEnd()
19912 
 
19913 
  def write(self, oprot):
19914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19916 
      return
19917 
    oprot.writeStructBegin('getCancelledOrders_args')
19918 
    if self.cancelDateFrom is not None:
19919 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
19920 
      oprot.writeI64(self.cancelDateFrom)
19921 
      oprot.writeFieldEnd()
19922 
    if self.cancelDateTo is not None:
19923 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
19924 
      oprot.writeI64(self.cancelDateTo)
19925 
      oprot.writeFieldEnd()
19926 
    oprot.writeFieldStop()
19927 
    oprot.writeStructEnd()
19928 
 
19929 
  def validate(self):
19930 
    return
19931 
 
19932 
 
19933 
  def __repr__(self):
19934 
    L = ['%s=%r' % (key, value)
19935 
      for key, value in self.__dict__.iteritems()]
19936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19937 
 
19938 
  def __eq__(self, other):
19939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19940 
 
19941 
  def __ne__(self, other):
19942 
    return not (self == other)
19943 
 
19944 
class getCancelledOrders_result:
19945 
  """
19946 
  Attributes:
19947 
   - success
19948 
   - ex
19949 
  """
19950 
 
19951 
  thrift_spec = (
19952 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19953 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19954 
  )
19955 
 
19956 
  def __init__(self, success=None, ex=None,):
19957 
    self.success = success
19958 
    self.ex = ex
19959 
 
19960 
  def read(self, iprot):
19961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19963 
      return
19964 
    iprot.readStructBegin()
19965 
    while True:
19966 
      (fname, ftype, fid) = iprot.readFieldBegin()
19967 
      if ftype == TType.STOP:
19968 
        break
19969 
      if fid == 0:
19970 
        if ftype == TType.LIST:
19971 
          self.success = []
5031 varun.gupt 19972 
          (_etype449, _size446) = iprot.readListBegin()
19973 
          for _i450 in xrange(_size446):
19974 
            _elem451 = Order()
19975 
            _elem451.read(iprot)
19976 
            self.success.append(_elem451)
4709 rajveer 19977 
          iprot.readListEnd()
19978 
        else:
19979 
          iprot.skip(ftype)
19980 
      elif fid == 1:
19981 
        if ftype == TType.STRUCT:
19982 
          self.ex = TransactionServiceException()
19983 
          self.ex.read(iprot)
19984 
        else:
19985 
          iprot.skip(ftype)
19986 
      else:
19987 
        iprot.skip(ftype)
19988 
      iprot.readFieldEnd()
19989 
    iprot.readStructEnd()
19990 
 
19991 
  def write(self, oprot):
19992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19994 
      return
19995 
    oprot.writeStructBegin('getCancelledOrders_result')
19996 
    if self.success is not None:
19997 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19998 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19999 
      for iter452 in self.success:
20000 
        iter452.write(oprot)
4709 rajveer 20001 
      oprot.writeListEnd()
20002 
      oprot.writeFieldEnd()
20003 
    if self.ex is not None:
20004 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20005 
      self.ex.write(oprot)
20006 
      oprot.writeFieldEnd()
20007 
    oprot.writeFieldStop()
20008 
    oprot.writeStructEnd()
20009 
 
20010 
  def validate(self):
20011 
    return
20012 
 
20013 
 
20014 
  def __repr__(self):
20015 
    L = ['%s=%r' % (key, value)
20016 
      for key, value in self.__dict__.iteritems()]
20017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20018 
 
20019 
  def __eq__(self, other):
20020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20021 
 
20022 
  def __ne__(self, other):
20023 
    return not (self == other)
20024 
 
4600 varun.gupt 20025 
class saveBluedartSettlements_args:
20026 
  """
20027 
  Attributes:
20028 
   - mapAWBAndAmount
20029 
  """
20030 
 
20031 
  thrift_spec = (
20032 
    None, # 0
20033 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
20034 
  )
20035 
 
20036 
  def __init__(self, mapAWBAndAmount=None,):
20037 
    self.mapAWBAndAmount = mapAWBAndAmount
20038 
 
20039 
  def read(self, iprot):
20040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20042 
      return
20043 
    iprot.readStructBegin()
20044 
    while True:
20045 
      (fname, ftype, fid) = iprot.readFieldBegin()
20046 
      if ftype == TType.STOP:
20047 
        break
20048 
      if fid == 1:
20049 
        if ftype == TType.MAP:
20050 
          self.mapAWBAndAmount = {}
5031 varun.gupt 20051 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
20052 
          for _i457 in xrange(_size453):
20053 
            _key458 = iprot.readI64();
20054 
            _val459 = iprot.readDouble();
20055 
            self.mapAWBAndAmount[_key458] = _val459
4600 varun.gupt 20056 
          iprot.readMapEnd()
20057 
        else:
20058 
          iprot.skip(ftype)
20059 
      else:
20060 
        iprot.skip(ftype)
20061 
      iprot.readFieldEnd()
20062 
    iprot.readStructEnd()
20063 
 
20064 
  def write(self, oprot):
20065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20067 
      return
20068 
    oprot.writeStructBegin('saveBluedartSettlements_args')
20069 
    if self.mapAWBAndAmount is not None:
20070 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
20071 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
5031 varun.gupt 20072 
      for kiter460,viter461 in self.mapAWBAndAmount.items():
20073 
        oprot.writeI64(kiter460)
20074 
        oprot.writeDouble(viter461)
4600 varun.gupt 20075 
      oprot.writeMapEnd()
20076 
      oprot.writeFieldEnd()
20077 
    oprot.writeFieldStop()
20078 
    oprot.writeStructEnd()
20079 
 
20080 
  def validate(self):
20081 
    return
20082 
 
20083 
 
20084 
  def __repr__(self):
20085 
    L = ['%s=%r' % (key, value)
20086 
      for key, value in self.__dict__.iteritems()]
20087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20088 
 
20089 
  def __eq__(self, other):
20090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20091 
 
20092 
  def __ne__(self, other):
20093 
    return not (self == other)
20094 
 
20095 
class saveBluedartSettlements_result:
20096 
  """
20097 
  Attributes:
20098 
   - ex
20099 
  """
20100 
 
20101 
  thrift_spec = (
20102 
    None, # 0
20103 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20104 
  )
20105 
 
20106 
  def __init__(self, ex=None,):
20107 
    self.ex = ex
20108 
 
20109 
  def read(self, iprot):
20110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20112 
      return
20113 
    iprot.readStructBegin()
20114 
    while True:
20115 
      (fname, ftype, fid) = iprot.readFieldBegin()
20116 
      if ftype == TType.STOP:
20117 
        break
20118 
      if fid == 1:
20119 
        if ftype == TType.STRUCT:
20120 
          self.ex = TransactionServiceException()
20121 
          self.ex.read(iprot)
20122 
        else:
20123 
          iprot.skip(ftype)
20124 
      else:
20125 
        iprot.skip(ftype)
20126 
      iprot.readFieldEnd()
20127 
    iprot.readStructEnd()
20128 
 
20129 
  def write(self, oprot):
20130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20132 
      return
20133 
    oprot.writeStructBegin('saveBluedartSettlements_result')
20134 
    if self.ex is not None:
20135 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20136 
      self.ex.write(oprot)
20137 
      oprot.writeFieldEnd()
20138 
    oprot.writeFieldStop()
20139 
    oprot.writeStructEnd()
20140 
 
20141 
  def validate(self):
20142 
    return
20143 
 
20144 
 
20145 
  def __repr__(self):
20146 
    L = ['%s=%r' % (key, value)
20147 
      for key, value in self.__dict__.iteritems()]
20148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20149 
 
20150 
  def __eq__(self, other):
20151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20152 
 
20153 
  def __ne__(self, other):
20154 
    return not (self == other)
20155 
 
20156 
class savePaymentSettlements_args:
20157 
  """
20158 
  Attributes:
20159 
   - settlementDate
20160 
   - paymentGatewayId
4905 varun.gupt 20161 
   - referenceId
4600 varun.gupt 20162 
   - serviceTax
20163 
   - otherCharges
20164 
   - netCollection
20165 
  """
20166 
 
20167 
  thrift_spec = (
20168 
    None, # 0
20169 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
20170 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 20171 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 20172 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
20173 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
20174 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
20175 
  )
20176 
 
4905 varun.gupt 20177 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 20178 
    self.settlementDate = settlementDate
20179 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 20180 
    self.referenceId = referenceId
4600 varun.gupt 20181 
    self.serviceTax = serviceTax
20182 
    self.otherCharges = otherCharges
20183 
    self.netCollection = netCollection
20184 
 
20185 
  def read(self, iprot):
20186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20188 
      return
20189 
    iprot.readStructBegin()
20190 
    while True:
20191 
      (fname, ftype, fid) = iprot.readFieldBegin()
20192 
      if ftype == TType.STOP:
20193 
        break
20194 
      if fid == 1:
20195 
        if ftype == TType.I64:
20196 
          self.settlementDate = iprot.readI64();
20197 
        else:
20198 
          iprot.skip(ftype)
20199 
      elif fid == 2:
20200 
        if ftype == TType.I64:
20201 
          self.paymentGatewayId = iprot.readI64();
20202 
        else:
20203 
          iprot.skip(ftype)
20204 
      elif fid == 3:
20205 
        if ftype == TType.I64:
4905 varun.gupt 20206 
          self.referenceId = iprot.readI64();
4600 varun.gupt 20207 
        else:
20208 
          iprot.skip(ftype)
20209 
      elif fid == 4:
20210 
        if ftype == TType.DOUBLE:
20211 
          self.serviceTax = iprot.readDouble();
20212 
        else:
20213 
          iprot.skip(ftype)
20214 
      elif fid == 5:
20215 
        if ftype == TType.DOUBLE:
20216 
          self.otherCharges = iprot.readDouble();
20217 
        else:
20218 
          iprot.skip(ftype)
20219 
      elif fid == 6:
20220 
        if ftype == TType.DOUBLE:
20221 
          self.netCollection = iprot.readDouble();
20222 
        else:
20223 
          iprot.skip(ftype)
20224 
      else:
20225 
        iprot.skip(ftype)
20226 
      iprot.readFieldEnd()
20227 
    iprot.readStructEnd()
20228 
 
20229 
  def write(self, oprot):
20230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20232 
      return
20233 
    oprot.writeStructBegin('savePaymentSettlements_args')
20234 
    if self.settlementDate is not None:
20235 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
20236 
      oprot.writeI64(self.settlementDate)
20237 
      oprot.writeFieldEnd()
20238 
    if self.paymentGatewayId is not None:
20239 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
20240 
      oprot.writeI64(self.paymentGatewayId)
20241 
      oprot.writeFieldEnd()
4905 varun.gupt 20242 
    if self.referenceId is not None:
20243 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
20244 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 20245 
      oprot.writeFieldEnd()
20246 
    if self.serviceTax is not None:
20247 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
20248 
      oprot.writeDouble(self.serviceTax)
20249 
      oprot.writeFieldEnd()
20250 
    if self.otherCharges is not None:
20251 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
20252 
      oprot.writeDouble(self.otherCharges)
20253 
      oprot.writeFieldEnd()
20254 
    if self.netCollection is not None:
20255 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
20256 
      oprot.writeDouble(self.netCollection)
20257 
      oprot.writeFieldEnd()
20258 
    oprot.writeFieldStop()
20259 
    oprot.writeStructEnd()
20260 
 
20261 
  def validate(self):
20262 
    return
20263 
 
20264 
 
20265 
  def __repr__(self):
20266 
    L = ['%s=%r' % (key, value)
20267 
      for key, value in self.__dict__.iteritems()]
20268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20269 
 
20270 
  def __eq__(self, other):
20271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20272 
 
20273 
  def __ne__(self, other):
20274 
    return not (self == other)
20275 
 
20276 
class savePaymentSettlements_result:
20277 
  """
20278 
  Attributes:
20279 
   - ex
20280 
  """
20281 
 
20282 
  thrift_spec = (
20283 
    None, # 0
20284 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20285 
  )
20286 
 
20287 
  def __init__(self, ex=None,):
20288 
    self.ex = ex
20289 
 
20290 
  def read(self, iprot):
20291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20293 
      return
20294 
    iprot.readStructBegin()
20295 
    while True:
20296 
      (fname, ftype, fid) = iprot.readFieldBegin()
20297 
      if ftype == TType.STOP:
20298 
        break
20299 
      if fid == 1:
20300 
        if ftype == TType.STRUCT:
20301 
          self.ex = TransactionServiceException()
20302 
          self.ex.read(iprot)
20303 
        else:
20304 
          iprot.skip(ftype)
20305 
      else:
20306 
        iprot.skip(ftype)
20307 
      iprot.readFieldEnd()
20308 
    iprot.readStructEnd()
20309 
 
20310 
  def write(self, oprot):
20311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20313 
      return
20314 
    oprot.writeStructBegin('savePaymentSettlements_result')
20315 
    if self.ex is not None:
20316 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20317 
      self.ex.write(oprot)
20318 
      oprot.writeFieldEnd()
20319 
    oprot.writeFieldStop()
20320 
    oprot.writeStructEnd()
20321 
 
20322 
  def validate(self):
20323 
    return
20324 
 
20325 
 
20326 
  def __repr__(self):
20327 
    L = ['%s=%r' % (key, value)
20328 
      for key, value in self.__dict__.iteritems()]
20329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20330 
 
20331 
  def __eq__(self, other):
20332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20333 
 
20334 
  def __ne__(self, other):
20335 
    return not (self == other)
20336 
 
20337 
class saveEBSSettlementSummary_args:
20338 
  """
20339 
  Attributes:
20340 
   - settlementId
20341 
   - settlementDate
20342 
   - transactionDateFrom
20343 
   - transactionDateTo
20344 
   - amount
20345 
  """
20346 
 
20347 
  thrift_spec = (
20348 
    None, # 0
20349 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20350 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
20351 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
20352 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
20353 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
20354 
  )
20355 
 
20356 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
20357 
    self.settlementId = settlementId
20358 
    self.settlementDate = settlementDate
20359 
    self.transactionDateFrom = transactionDateFrom
20360 
    self.transactionDateTo = transactionDateTo
20361 
    self.amount = amount
20362 
 
20363 
  def read(self, iprot):
20364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20366 
      return
20367 
    iprot.readStructBegin()
20368 
    while True:
20369 
      (fname, ftype, fid) = iprot.readFieldBegin()
20370 
      if ftype == TType.STOP:
20371 
        break
20372 
      if fid == 1:
20373 
        if ftype == TType.I64:
20374 
          self.settlementId = iprot.readI64();
20375 
        else:
20376 
          iprot.skip(ftype)
20377 
      elif fid == 2:
20378 
        if ftype == TType.I64:
20379 
          self.settlementDate = iprot.readI64();
20380 
        else:
20381 
          iprot.skip(ftype)
20382 
      elif fid == 3:
20383 
        if ftype == TType.I64:
20384 
          self.transactionDateFrom = iprot.readI64();
20385 
        else:
20386 
          iprot.skip(ftype)
20387 
      elif fid == 4:
20388 
        if ftype == TType.I64:
20389 
          self.transactionDateTo = iprot.readI64();
20390 
        else:
20391 
          iprot.skip(ftype)
20392 
      elif fid == 5:
20393 
        if ftype == TType.DOUBLE:
20394 
          self.amount = iprot.readDouble();
20395 
        else:
20396 
          iprot.skip(ftype)
20397 
      else:
20398 
        iprot.skip(ftype)
20399 
      iprot.readFieldEnd()
20400 
    iprot.readStructEnd()
20401 
 
20402 
  def write(self, oprot):
20403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20405 
      return
20406 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
20407 
    if self.settlementId is not None:
20408 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20409 
      oprot.writeI64(self.settlementId)
20410 
      oprot.writeFieldEnd()
20411 
    if self.settlementDate is not None:
20412 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
20413 
      oprot.writeI64(self.settlementDate)
20414 
      oprot.writeFieldEnd()
20415 
    if self.transactionDateFrom is not None:
20416 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
20417 
      oprot.writeI64(self.transactionDateFrom)
20418 
      oprot.writeFieldEnd()
20419 
    if self.transactionDateTo is not None:
20420 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
20421 
      oprot.writeI64(self.transactionDateTo)
20422 
      oprot.writeFieldEnd()
20423 
    if self.amount is not None:
20424 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
20425 
      oprot.writeDouble(self.amount)
20426 
      oprot.writeFieldEnd()
20427 
    oprot.writeFieldStop()
20428 
    oprot.writeStructEnd()
20429 
 
20430 
  def validate(self):
20431 
    return
20432 
 
20433 
 
20434 
  def __repr__(self):
20435 
    L = ['%s=%r' % (key, value)
20436 
      for key, value in self.__dict__.iteritems()]
20437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20438 
 
20439 
  def __eq__(self, other):
20440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20441 
 
20442 
  def __ne__(self, other):
20443 
    return not (self == other)
20444 
 
20445 
class saveEBSSettlementSummary_result:
20446 
  """
20447 
  Attributes:
20448 
   - ex
20449 
  """
20450 
 
20451 
  thrift_spec = (
20452 
    None, # 0
20453 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20454 
  )
20455 
 
20456 
  def __init__(self, ex=None,):
20457 
    self.ex = ex
20458 
 
20459 
  def read(self, iprot):
20460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20462 
      return
20463 
    iprot.readStructBegin()
20464 
    while True:
20465 
      (fname, ftype, fid) = iprot.readFieldBegin()
20466 
      if ftype == TType.STOP:
20467 
        break
20468 
      if fid == 1:
20469 
        if ftype == TType.STRUCT:
20470 
          self.ex = TransactionServiceException()
20471 
          self.ex.read(iprot)
20472 
        else:
20473 
          iprot.skip(ftype)
20474 
      else:
20475 
        iprot.skip(ftype)
20476 
      iprot.readFieldEnd()
20477 
    iprot.readStructEnd()
20478 
 
20479 
  def write(self, oprot):
20480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20482 
      return
20483 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
20484 
    if self.ex is not None:
20485 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20486 
      self.ex.write(oprot)
20487 
      oprot.writeFieldEnd()
20488 
    oprot.writeFieldStop()
20489 
    oprot.writeStructEnd()
20490 
 
20491 
  def validate(self):
20492 
    return
20493 
 
20494 
 
20495 
  def __repr__(self):
20496 
    L = ['%s=%r' % (key, value)
20497 
      for key, value in self.__dict__.iteritems()]
20498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20499 
 
20500 
  def __eq__(self, other):
20501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20502 
 
20503 
  def __ne__(self, other):
20504 
    return not (self == other)
20505 
 
20506 
class getSettlementForPaymentId_args:
20507 
  """
20508 
  Attributes:
20509 
   - paymentId
20510 
  """
20511 
 
20512 
  thrift_spec = (
20513 
    None, # 0
20514 
    (1, TType.I64, 'paymentId', None, None, ), # 1
20515 
  )
20516 
 
20517 
  def __init__(self, paymentId=None,):
20518 
    self.paymentId = paymentId
20519 
 
20520 
  def read(self, iprot):
20521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20523 
      return
20524 
    iprot.readStructBegin()
20525 
    while True:
20526 
      (fname, ftype, fid) = iprot.readFieldBegin()
20527 
      if ftype == TType.STOP:
20528 
        break
20529 
      if fid == 1:
20530 
        if ftype == TType.I64:
20531 
          self.paymentId = iprot.readI64();
20532 
        else:
20533 
          iprot.skip(ftype)
20534 
      else:
20535 
        iprot.skip(ftype)
20536 
      iprot.readFieldEnd()
20537 
    iprot.readStructEnd()
20538 
 
20539 
  def write(self, oprot):
20540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20542 
      return
20543 
    oprot.writeStructBegin('getSettlementForPaymentId_args')
20544 
    if self.paymentId is not None:
20545 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
20546 
      oprot.writeI64(self.paymentId)
20547 
      oprot.writeFieldEnd()
20548 
    oprot.writeFieldStop()
20549 
    oprot.writeStructEnd()
20550 
 
20551 
  def validate(self):
20552 
    return
20553 
 
20554 
 
20555 
  def __repr__(self):
20556 
    L = ['%s=%r' % (key, value)
20557 
      for key, value in self.__dict__.iteritems()]
20558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20559 
 
20560 
  def __eq__(self, other):
20561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20562 
 
20563 
  def __ne__(self, other):
20564 
    return not (self == other)
20565 
 
20566 
class getSettlementForPaymentId_result:
20567 
  """
20568 
  Attributes:
20569 
   - success
20570 
   - ex
20571 
  """
20572 
 
20573 
  thrift_spec = (
20574 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
20575 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20576 
  )
20577 
 
20578 
  def __init__(self, success=None, ex=None,):
20579 
    self.success = success
20580 
    self.ex = ex
20581 
 
20582 
  def read(self, iprot):
20583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20585 
      return
20586 
    iprot.readStructBegin()
20587 
    while True:
20588 
      (fname, ftype, fid) = iprot.readFieldBegin()
20589 
      if ftype == TType.STOP:
20590 
        break
20591 
      if fid == 0:
20592 
        if ftype == TType.STRUCT:
20593 
          self.success = PaymentSettlement()
20594 
          self.success.read(iprot)
20595 
        else:
20596 
          iprot.skip(ftype)
20597 
      elif fid == 1:
20598 
        if ftype == TType.STRUCT:
20599 
          self.ex = TransactionServiceException()
20600 
          self.ex.read(iprot)
20601 
        else:
20602 
          iprot.skip(ftype)
20603 
      else:
20604 
        iprot.skip(ftype)
20605 
      iprot.readFieldEnd()
20606 
    iprot.readStructEnd()
20607 
 
20608 
  def write(self, oprot):
20609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20611 
      return
20612 
    oprot.writeStructBegin('getSettlementForPaymentId_result')
20613 
    if self.success is not None:
20614 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20615 
      self.success.write(oprot)
20616 
      oprot.writeFieldEnd()
20617 
    if self.ex is not None:
20618 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20619 
      self.ex.write(oprot)
20620 
      oprot.writeFieldEnd()
20621 
    oprot.writeFieldStop()
20622 
    oprot.writeStructEnd()
20623 
 
20624 
  def validate(self):
20625 
    return
20626 
 
20627 
 
20628 
  def __repr__(self):
20629 
    L = ['%s=%r' % (key, value)
20630 
      for key, value in self.__dict__.iteritems()]
20631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20632 
 
20633 
  def __eq__(self, other):
20634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20635 
 
20636 
  def __ne__(self, other):
20637 
    return not (self == other)
20638 
 
20639 
class getEBSSettlementSummaries_args:
20640 
 
20641 
  thrift_spec = (
20642 
  )
20643 
 
20644 
  def read(self, iprot):
20645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20647 
      return
20648 
    iprot.readStructBegin()
20649 
    while True:
20650 
      (fname, ftype, fid) = iprot.readFieldBegin()
20651 
      if ftype == TType.STOP:
20652 
        break
20653 
      else:
20654 
        iprot.skip(ftype)
20655 
      iprot.readFieldEnd()
20656 
    iprot.readStructEnd()
20657 
 
20658 
  def write(self, oprot):
20659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20661 
      return
20662 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
20663 
    oprot.writeFieldStop()
20664 
    oprot.writeStructEnd()
20665 
 
20666 
  def validate(self):
20667 
    return
20668 
 
20669 
 
20670 
  def __repr__(self):
20671 
    L = ['%s=%r' % (key, value)
20672 
      for key, value in self.__dict__.iteritems()]
20673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20674 
 
20675 
  def __eq__(self, other):
20676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20677 
 
20678 
  def __ne__(self, other):
20679 
    return not (self == other)
20680 
 
20681 
class getEBSSettlementSummaries_result:
20682 
  """
20683 
  Attributes:
20684 
   - success
20685 
   - ex
20686 
  """
20687 
 
20688 
  thrift_spec = (
20689 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
20690 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20691 
  )
20692 
 
20693 
  def __init__(self, success=None, ex=None,):
20694 
    self.success = success
20695 
    self.ex = ex
20696 
 
20697 
  def read(self, iprot):
20698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20700 
      return
20701 
    iprot.readStructBegin()
20702 
    while True:
20703 
      (fname, ftype, fid) = iprot.readFieldBegin()
20704 
      if ftype == TType.STOP:
20705 
        break
20706 
      if fid == 0:
20707 
        if ftype == TType.MAP:
20708 
          self.success = {}
5031 varun.gupt 20709 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20710 
          for _i466 in xrange(_size462):
20711 
            _key467 = iprot.readI64();
20712 
            _val468 = iprot.readString();
20713 
            self.success[_key467] = _val468
4600 varun.gupt 20714 
          iprot.readMapEnd()
20715 
        else:
20716 
          iprot.skip(ftype)
20717 
      elif fid == 1:
20718 
        if ftype == TType.STRUCT:
20719 
          self.ex = TransactionServiceException()
20720 
          self.ex.read(iprot)
20721 
        else:
20722 
          iprot.skip(ftype)
20723 
      else:
20724 
        iprot.skip(ftype)
20725 
      iprot.readFieldEnd()
20726 
    iprot.readStructEnd()
20727 
 
20728 
  def write(self, oprot):
20729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20731 
      return
20732 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
20733 
    if self.success is not None:
20734 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20735 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
5031 varun.gupt 20736 
      for kiter469,viter470 in self.success.items():
20737 
        oprot.writeI64(kiter469)
20738 
        oprot.writeString(viter470)
4600 varun.gupt 20739 
      oprot.writeMapEnd()
20740 
      oprot.writeFieldEnd()
20741 
    if self.ex is not None:
20742 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20743 
      self.ex.write(oprot)
20744 
      oprot.writeFieldEnd()
20745 
    oprot.writeFieldStop()
20746 
    oprot.writeStructEnd()
20747 
 
20748 
  def validate(self):
20749 
    return
20750 
 
20751 
 
20752 
  def __repr__(self):
20753 
    L = ['%s=%r' % (key, value)
20754 
      for key, value in self.__dict__.iteritems()]
20755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20756 
 
20757 
  def __eq__(self, other):
20758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20759 
 
20760 
  def __ne__(self, other):
20761 
    return not (self == other)
20762 
 
20763 
class markEBSSettlementUploaded_args:
20764 
  """
20765 
  Attributes:
20766 
   - settlementId
20767 
  """
20768 
 
20769 
  thrift_spec = (
20770 
    None, # 0
20771 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20772 
  )
20773 
 
20774 
  def __init__(self, settlementId=None,):
20775 
    self.settlementId = settlementId
20776 
 
20777 
  def read(self, iprot):
20778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20780 
      return
20781 
    iprot.readStructBegin()
20782 
    while True:
20783 
      (fname, ftype, fid) = iprot.readFieldBegin()
20784 
      if ftype == TType.STOP:
20785 
        break
20786 
      if fid == 1:
20787 
        if ftype == TType.I64:
20788 
          self.settlementId = iprot.readI64();
20789 
        else:
20790 
          iprot.skip(ftype)
20791 
      else:
20792 
        iprot.skip(ftype)
20793 
      iprot.readFieldEnd()
20794 
    iprot.readStructEnd()
20795 
 
20796 
  def write(self, oprot):
20797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20799 
      return
20800 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
20801 
    if self.settlementId is not None:
20802 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20803 
      oprot.writeI64(self.settlementId)
20804 
      oprot.writeFieldEnd()
20805 
    oprot.writeFieldStop()
20806 
    oprot.writeStructEnd()
20807 
 
20808 
  def validate(self):
20809 
    return
20810 
 
20811 
 
20812 
  def __repr__(self):
20813 
    L = ['%s=%r' % (key, value)
20814 
      for key, value in self.__dict__.iteritems()]
20815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20816 
 
20817 
  def __eq__(self, other):
20818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20819 
 
20820 
  def __ne__(self, other):
20821 
    return not (self == other)
20822 
 
20823 
class markEBSSettlementUploaded_result:
20824 
  """
20825 
  Attributes:
20826 
   - ex
20827 
  """
20828 
 
20829 
  thrift_spec = (
20830 
    None, # 0
20831 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20832 
  )
20833 
 
20834 
  def __init__(self, ex=None,):
20835 
    self.ex = ex
20836 
 
20837 
  def read(self, iprot):
20838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20840 
      return
20841 
    iprot.readStructBegin()
20842 
    while True:
20843 
      (fname, ftype, fid) = iprot.readFieldBegin()
20844 
      if ftype == TType.STOP:
20845 
        break
20846 
      if fid == 1:
20847 
        if ftype == TType.STRUCT:
20848 
          self.ex = TransactionServiceException()
20849 
          self.ex.read(iprot)
20850 
        else:
20851 
          iprot.skip(ftype)
20852 
      else:
20853 
        iprot.skip(ftype)
20854 
      iprot.readFieldEnd()
20855 
    iprot.readStructEnd()
20856 
 
20857 
  def write(self, oprot):
20858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20860 
      return
20861 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
20862 
    if self.ex is not None:
20863 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20864 
      self.ex.write(oprot)
20865 
      oprot.writeFieldEnd()
20866 
    oprot.writeFieldStop()
20867 
    oprot.writeStructEnd()
20868 
 
20869 
  def validate(self):
20870 
    return
20871 
 
20872 
 
20873 
  def __repr__(self):
20874 
    L = ['%s=%r' % (key, value)
20875 
      for key, value in self.__dict__.iteritems()]
20876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20877 
 
20878 
  def __eq__(self, other):
20879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20880 
 
20881 
  def __ne__(self, other):
20882 
    return not (self == other)
20883 
 
20884 
class getEBSSettlementDate_args:
20885 
  """
20886 
  Attributes:
20887 
   - settlementId
20888 
  """
20889 
 
20890 
  thrift_spec = (
20891 
    None, # 0
20892 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20893 
  )
20894 
 
20895 
  def __init__(self, settlementId=None,):
20896 
    self.settlementId = settlementId
20897 
 
20898 
  def read(self, iprot):
20899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20901 
      return
20902 
    iprot.readStructBegin()
20903 
    while True:
20904 
      (fname, ftype, fid) = iprot.readFieldBegin()
20905 
      if ftype == TType.STOP:
20906 
        break
20907 
      if fid == 1:
20908 
        if ftype == TType.I64:
20909 
          self.settlementId = iprot.readI64();
20910 
        else:
20911 
          iprot.skip(ftype)
20912 
      else:
20913 
        iprot.skip(ftype)
20914 
      iprot.readFieldEnd()
20915 
    iprot.readStructEnd()
20916 
 
20917 
  def write(self, oprot):
20918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20920 
      return
20921 
    oprot.writeStructBegin('getEBSSettlementDate_args')
20922 
    if self.settlementId is not None:
20923 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20924 
      oprot.writeI64(self.settlementId)
20925 
      oprot.writeFieldEnd()
20926 
    oprot.writeFieldStop()
20927 
    oprot.writeStructEnd()
20928 
 
20929 
  def validate(self):
20930 
    return
20931 
 
20932 
 
20933 
  def __repr__(self):
20934 
    L = ['%s=%r' % (key, value)
20935 
      for key, value in self.__dict__.iteritems()]
20936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20937 
 
20938 
  def __eq__(self, other):
20939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20940 
 
20941 
  def __ne__(self, other):
20942 
    return not (self == other)
20943 
 
20944 
class getEBSSettlementDate_result:
20945 
  """
20946 
  Attributes:
20947 
   - success
20948 
   - ex
20949 
  """
20950 
 
20951 
  thrift_spec = (
20952 
    (0, TType.I64, 'success', None, None, ), # 0
20953 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20954 
  )
20955 
 
20956 
  def __init__(self, success=None, ex=None,):
20957 
    self.success = success
20958 
    self.ex = ex
20959 
 
20960 
  def read(self, iprot):
20961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20963 
      return
20964 
    iprot.readStructBegin()
20965 
    while True:
20966 
      (fname, ftype, fid) = iprot.readFieldBegin()
20967 
      if ftype == TType.STOP:
20968 
        break
20969 
      if fid == 0:
20970 
        if ftype == TType.I64:
20971 
          self.success = iprot.readI64();
20972 
        else:
20973 
          iprot.skip(ftype)
20974 
      elif fid == 1:
20975 
        if ftype == TType.STRUCT:
20976 
          self.ex = TransactionServiceException()
20977 
          self.ex.read(iprot)
20978 
        else:
20979 
          iprot.skip(ftype)
20980 
      else:
20981 
        iprot.skip(ftype)
20982 
      iprot.readFieldEnd()
20983 
    iprot.readStructEnd()
20984 
 
20985 
  def write(self, oprot):
20986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20988 
      return
20989 
    oprot.writeStructBegin('getEBSSettlementDate_result')
20990 
    if self.success is not None:
20991 
      oprot.writeFieldBegin('success', TType.I64, 0)
20992 
      oprot.writeI64(self.success)
20993 
      oprot.writeFieldEnd()
20994 
    if self.ex is not None:
20995 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20996 
      self.ex.write(oprot)
20997 
      oprot.writeFieldEnd()
20998 
    oprot.writeFieldStop()
20999 
    oprot.writeStructEnd()
21000 
 
21001 
  def validate(self):
21002 
    return
21003 
 
21004 
 
21005 
  def __repr__(self):
21006 
    L = ['%s=%r' % (key, value)
21007 
      for key, value in self.__dict__.iteritems()]
21008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21009 
 
21010 
  def __eq__(self, other):
21011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21012 
 
21013 
  def __ne__(self, other):
21014 
    return not (self == other)
4715 varun.gupt 21015 
 
21016 
class getSettlementsByDate_args:
21017 
  """
21018 
  Attributes:
21019 
   - settlementDateFrom
21020 
   - settlementDateTo
21021 
   - isRefund
21022 
  """
21023 
 
21024 
  thrift_spec = (
21025 
    None, # 0
21026 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
21027 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
21028 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
21029 
  )
21030 
 
21031 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
21032 
    self.settlementDateFrom = settlementDateFrom
21033 
    self.settlementDateTo = settlementDateTo
21034 
    self.isRefund = isRefund
21035 
 
21036 
  def read(self, iprot):
21037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21039 
      return
21040 
    iprot.readStructBegin()
21041 
    while True:
21042 
      (fname, ftype, fid) = iprot.readFieldBegin()
21043 
      if ftype == TType.STOP:
21044 
        break
21045 
      if fid == 1:
21046 
        if ftype == TType.I64:
21047 
          self.settlementDateFrom = iprot.readI64();
21048 
        else:
21049 
          iprot.skip(ftype)
21050 
      elif fid == 2:
21051 
        if ftype == TType.I64:
21052 
          self.settlementDateTo = iprot.readI64();
21053 
        else:
21054 
          iprot.skip(ftype)
21055 
      elif fid == 3:
21056 
        if ftype == TType.BOOL:
21057 
          self.isRefund = iprot.readBool();
21058 
        else:
21059 
          iprot.skip(ftype)
21060 
      else:
21061 
        iprot.skip(ftype)
21062 
      iprot.readFieldEnd()
21063 
    iprot.readStructEnd()
21064 
 
21065 
  def write(self, oprot):
21066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21068 
      return
21069 
    oprot.writeStructBegin('getSettlementsByDate_args')
21070 
    if self.settlementDateFrom is not None:
21071 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
21072 
      oprot.writeI64(self.settlementDateFrom)
21073 
      oprot.writeFieldEnd()
21074 
    if self.settlementDateTo is not None:
21075 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
21076 
      oprot.writeI64(self.settlementDateTo)
21077 
      oprot.writeFieldEnd()
21078 
    if self.isRefund is not None:
21079 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
21080 
      oprot.writeBool(self.isRefund)
21081 
      oprot.writeFieldEnd()
21082 
    oprot.writeFieldStop()
21083 
    oprot.writeStructEnd()
21084 
 
21085 
  def validate(self):
21086 
    return
21087 
 
21088 
 
21089 
  def __repr__(self):
21090 
    L = ['%s=%r' % (key, value)
21091 
      for key, value in self.__dict__.iteritems()]
21092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21093 
 
21094 
  def __eq__(self, other):
21095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21096 
 
21097 
  def __ne__(self, other):
21098 
    return not (self == other)
21099 
 
21100 
class getSettlementsByDate_result:
21101 
  """
21102 
  Attributes:
21103 
   - success
21104 
   - ex
21105 
  """
21106 
 
21107 
  thrift_spec = (
21108 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
21109 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21110 
  )
21111 
 
21112 
  def __init__(self, success=None, ex=None,):
21113 
    self.success = success
21114 
    self.ex = ex
21115 
 
21116 
  def read(self, iprot):
21117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21119 
      return
21120 
    iprot.readStructBegin()
21121 
    while True:
21122 
      (fname, ftype, fid) = iprot.readFieldBegin()
21123 
      if ftype == TType.STOP:
21124 
        break
21125 
      if fid == 0:
21126 
        if ftype == TType.LIST:
21127 
          self.success = []
5031 varun.gupt 21128 
          (_etype474, _size471) = iprot.readListBegin()
21129 
          for _i475 in xrange(_size471):
21130 
            _elem476 = PaymentSettlement()
21131 
            _elem476.read(iprot)
21132 
            self.success.append(_elem476)
4715 varun.gupt 21133 
          iprot.readListEnd()
21134 
        else:
21135 
          iprot.skip(ftype)
21136 
      elif fid == 1:
21137 
        if ftype == TType.STRUCT:
21138 
          self.ex = TransactionServiceException()
21139 
          self.ex.read(iprot)
21140 
        else:
21141 
          iprot.skip(ftype)
21142 
      else:
21143 
        iprot.skip(ftype)
21144 
      iprot.readFieldEnd()
21145 
    iprot.readStructEnd()
21146 
 
21147 
  def write(self, oprot):
21148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21150 
      return
21151 
    oprot.writeStructBegin('getSettlementsByDate_result')
21152 
    if self.success is not None:
21153 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21154 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 21155 
      for iter477 in self.success:
21156 
        iter477.write(oprot)
4715 varun.gupt 21157 
      oprot.writeListEnd()
21158 
      oprot.writeFieldEnd()
21159 
    if self.ex is not None:
21160 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21161 
      self.ex.write(oprot)
21162 
      oprot.writeFieldEnd()
21163 
    oprot.writeFieldStop()
21164 
    oprot.writeStructEnd()
21165 
 
21166 
  def validate(self):
21167 
    return
21168 
 
21169 
 
21170 
  def __repr__(self):
21171 
    L = ['%s=%r' % (key, value)
21172 
      for key, value in self.__dict__.iteritems()]
21173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21174 
 
21175 
  def __eq__(self, other):
21176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21177 
 
21178 
  def __ne__(self, other):
21179 
    return not (self == other)
21180 
 
21181 
class getReshippedOrderIds_args:
21182 
  """
21183 
  Attributes:
21184 
   - orderIds
21185 
  """
21186 
 
21187 
  thrift_spec = (
21188 
    None, # 0
21189 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
21190 
  )
21191 
 
21192 
  def __init__(self, orderIds=None,):
21193 
    self.orderIds = orderIds
21194 
 
21195 
  def read(self, iprot):
21196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21198 
      return
21199 
    iprot.readStructBegin()
21200 
    while True:
21201 
      (fname, ftype, fid) = iprot.readFieldBegin()
21202 
      if ftype == TType.STOP:
21203 
        break
21204 
      if fid == 1:
21205 
        if ftype == TType.LIST:
21206 
          self.orderIds = []
5031 varun.gupt 21207 
          (_etype481, _size478) = iprot.readListBegin()
21208 
          for _i482 in xrange(_size478):
21209 
            _elem483 = iprot.readI64();
21210 
            self.orderIds.append(_elem483)
4715 varun.gupt 21211 
          iprot.readListEnd()
21212 
        else:
21213 
          iprot.skip(ftype)
21214 
      else:
21215 
        iprot.skip(ftype)
21216 
      iprot.readFieldEnd()
21217 
    iprot.readStructEnd()
21218 
 
21219 
  def write(self, oprot):
21220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21222 
      return
21223 
    oprot.writeStructBegin('getReshippedOrderIds_args')
21224 
    if self.orderIds is not None:
21225 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
21226 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5031 varun.gupt 21227 
      for iter484 in self.orderIds:
21228 
        oprot.writeI64(iter484)
4715 varun.gupt 21229 
      oprot.writeListEnd()
21230 
      oprot.writeFieldEnd()
21231 
    oprot.writeFieldStop()
21232 
    oprot.writeStructEnd()
21233 
 
21234 
  def validate(self):
21235 
    return
21236 
 
21237 
 
21238 
  def __repr__(self):
21239 
    L = ['%s=%r' % (key, value)
21240 
      for key, value in self.__dict__.iteritems()]
21241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21242 
 
21243 
  def __eq__(self, other):
21244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21245 
 
21246 
  def __ne__(self, other):
21247 
    return not (self == other)
21248 
 
21249 
class getReshippedOrderIds_result:
21250 
  """
21251 
  Attributes:
21252 
   - success
21253 
   - ex
21254 
  """
21255 
 
21256 
  thrift_spec = (
21257 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21258 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21259 
  )
21260 
 
21261 
  def __init__(self, success=None, ex=None,):
21262 
    self.success = success
21263 
    self.ex = ex
21264 
 
21265 
  def read(self, iprot):
21266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21268 
      return
21269 
    iprot.readStructBegin()
21270 
    while True:
21271 
      (fname, ftype, fid) = iprot.readFieldBegin()
21272 
      if ftype == TType.STOP:
21273 
        break
21274 
      if fid == 0:
21275 
        if ftype == TType.LIST:
21276 
          self.success = []
5031 varun.gupt 21277 
          (_etype488, _size485) = iprot.readListBegin()
21278 
          for _i489 in xrange(_size485):
21279 
            _elem490 = iprot.readI64();
21280 
            self.success.append(_elem490)
4715 varun.gupt 21281 
          iprot.readListEnd()
21282 
        else:
21283 
          iprot.skip(ftype)
21284 
      elif fid == 1:
21285 
        if ftype == TType.STRUCT:
21286 
          self.ex = TransactionServiceException()
21287 
          self.ex.read(iprot)
21288 
        else:
21289 
          iprot.skip(ftype)
21290 
      else:
21291 
        iprot.skip(ftype)
21292 
      iprot.readFieldEnd()
21293 
    iprot.readStructEnd()
21294 
 
21295 
  def write(self, oprot):
21296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21298 
      return
21299 
    oprot.writeStructBegin('getReshippedOrderIds_result')
21300 
    if self.success is not None:
21301 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21302 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 21303 
      for iter491 in self.success:
21304 
        oprot.writeI64(iter491)
4715 varun.gupt 21305 
      oprot.writeListEnd()
21306 
      oprot.writeFieldEnd()
21307 
    if self.ex is not None:
21308 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21309 
      self.ex.write(oprot)
21310 
      oprot.writeFieldEnd()
21311 
    oprot.writeFieldStop()
21312 
    oprot.writeStructEnd()
21313 
 
21314 
  def validate(self):
21315 
    return
21316 
 
21317 
 
21318 
  def __repr__(self):
21319 
    L = ['%s=%r' % (key, value)
21320 
      for key, value in self.__dict__.iteritems()]
21321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21322 
 
21323 
  def __eq__(self, other):
21324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21325 
 
21326 
  def __ne__(self, other):
21327 
    return not (self == other)
4757 mandeep.dh 21328 
 
21329 
class updateOrdersAsPORaised_args:
21330 
  """
21331 
  Attributes:
21332 
   - itemIdQuantityMap
21333 
   - purchaseOrderId
21334 
   - warehouseId
21335 
  """
21336 
 
21337 
  thrift_spec = (
21338 
    None, # 0
21339 
    (1, TType.MAP, 'itemIdQuantityMap', (TType.I64,None,TType.I64,None), None, ), # 1
21340 
    (2, TType.I64, 'purchaseOrderId', None, None, ), # 2
21341 
    (3, TType.I64, 'warehouseId', None, None, ), # 3
21342 
  )
21343 
 
21344 
  def __init__(self, itemIdQuantityMap=None, purchaseOrderId=None, warehouseId=None,):
21345 
    self.itemIdQuantityMap = itemIdQuantityMap
21346 
    self.purchaseOrderId = purchaseOrderId
21347 
    self.warehouseId = warehouseId
21348 
 
21349 
  def read(self, iprot):
21350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21352 
      return
21353 
    iprot.readStructBegin()
21354 
    while True:
21355 
      (fname, ftype, fid) = iprot.readFieldBegin()
21356 
      if ftype == TType.STOP:
21357 
        break
21358 
      if fid == 1:
21359 
        if ftype == TType.MAP:
21360 
          self.itemIdQuantityMap = {}
5031 varun.gupt 21361 
          (_ktype493, _vtype494, _size492 ) = iprot.readMapBegin()
21362 
          for _i496 in xrange(_size492):
21363 
            _key497 = iprot.readI64();
21364 
            _val498 = iprot.readI64();
21365 
            self.itemIdQuantityMap[_key497] = _val498
4757 mandeep.dh 21366 
          iprot.readMapEnd()
21367 
        else:
21368 
          iprot.skip(ftype)
21369 
      elif fid == 2:
21370 
        if ftype == TType.I64:
21371 
          self.purchaseOrderId = iprot.readI64();
21372 
        else:
21373 
          iprot.skip(ftype)
21374 
      elif fid == 3:
21375 
        if ftype == TType.I64:
21376 
          self.warehouseId = iprot.readI64();
21377 
        else:
21378 
          iprot.skip(ftype)
21379 
      else:
21380 
        iprot.skip(ftype)
21381 
      iprot.readFieldEnd()
21382 
    iprot.readStructEnd()
21383 
 
21384 
  def write(self, oprot):
21385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21387 
      return
21388 
    oprot.writeStructBegin('updateOrdersAsPORaised_args')
21389 
    if self.itemIdQuantityMap is not None:
21390 
      oprot.writeFieldBegin('itemIdQuantityMap', TType.MAP, 1)
21391 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemIdQuantityMap))
5031 varun.gupt 21392 
      for kiter499,viter500 in self.itemIdQuantityMap.items():
21393 
        oprot.writeI64(kiter499)
21394 
        oprot.writeI64(viter500)
4757 mandeep.dh 21395 
      oprot.writeMapEnd()
21396 
      oprot.writeFieldEnd()
21397 
    if self.purchaseOrderId is not None:
21398 
      oprot.writeFieldBegin('purchaseOrderId', TType.I64, 2)
21399 
      oprot.writeI64(self.purchaseOrderId)
21400 
      oprot.writeFieldEnd()
21401 
    if self.warehouseId is not None:
21402 
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
21403 
      oprot.writeI64(self.warehouseId)
21404 
      oprot.writeFieldEnd()
21405 
    oprot.writeFieldStop()
21406 
    oprot.writeStructEnd()
21407 
 
21408 
  def validate(self):
21409 
    return
21410 
 
21411 
 
21412 
  def __repr__(self):
21413 
    L = ['%s=%r' % (key, value)
21414 
      for key, value in self.__dict__.iteritems()]
21415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21416 
 
21417 
  def __eq__(self, other):
21418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21419 
 
21420 
  def __ne__(self, other):
21421 
    return not (self == other)
21422 
 
21423 
class updateOrdersAsPORaised_result:
21424 
  """
21425 
  Attributes:
21426 
   - ex
21427 
  """
21428 
 
21429 
  thrift_spec = (
21430 
    None, # 0
21431 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21432 
  )
21433 
 
21434 
  def __init__(self, ex=None,):
21435 
    self.ex = ex
21436 
 
21437 
  def read(self, iprot):
21438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21440 
      return
21441 
    iprot.readStructBegin()
21442 
    while True:
21443 
      (fname, ftype, fid) = iprot.readFieldBegin()
21444 
      if ftype == TType.STOP:
21445 
        break
21446 
      if fid == 1:
21447 
        if ftype == TType.STRUCT:
21448 
          self.ex = TransactionServiceException()
21449 
          self.ex.read(iprot)
21450 
        else:
21451 
          iprot.skip(ftype)
21452 
      else:
21453 
        iprot.skip(ftype)
21454 
      iprot.readFieldEnd()
21455 
    iprot.readStructEnd()
21456 
 
21457 
  def write(self, oprot):
21458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21460 
      return
21461 
    oprot.writeStructBegin('updateOrdersAsPORaised_result')
21462 
    if self.ex is not None:
21463 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21464 
      self.ex.write(oprot)
21465 
      oprot.writeFieldEnd()
21466 
    oprot.writeFieldStop()
21467 
    oprot.writeStructEnd()
21468 
 
21469 
  def validate(self):
21470 
    return
21471 
 
21472 
 
21473 
  def __repr__(self):
21474 
    L = ['%s=%r' % (key, value)
21475 
      for key, value in self.__dict__.iteritems()]
21476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21477 
 
21478 
  def __eq__(self, other):
21479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21480 
 
21481 
  def __ne__(self, other):
21482 
    return not (self == other)
4875 varun.gupt 21483 
 
21484 
class getOrdersWhereVendorNotPaid_args:
21485 
  """
21486 
  Attributes:
21487 
   - vendorId
21488 
  """
21489 
 
21490 
  thrift_spec = (
21491 
    None, # 0
21492 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21493 
  )
21494 
 
21495 
  def __init__(self, vendorId=None,):
21496 
    self.vendorId = vendorId
21497 
 
21498 
  def read(self, iprot):
21499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21501 
      return
21502 
    iprot.readStructBegin()
21503 
    while True:
21504 
      (fname, ftype, fid) = iprot.readFieldBegin()
21505 
      if ftype == TType.STOP:
21506 
        break
21507 
      if fid == 1:
21508 
        if ftype == TType.I64:
21509 
          self.vendorId = iprot.readI64();
21510 
        else:
21511 
          iprot.skip(ftype)
21512 
      else:
21513 
        iprot.skip(ftype)
21514 
      iprot.readFieldEnd()
21515 
    iprot.readStructEnd()
21516 
 
21517 
  def write(self, oprot):
21518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21520 
      return
21521 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_args')
21522 
    if self.vendorId is not None:
21523 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21524 
      oprot.writeI64(self.vendorId)
21525 
      oprot.writeFieldEnd()
21526 
    oprot.writeFieldStop()
21527 
    oprot.writeStructEnd()
21528 
 
21529 
  def validate(self):
21530 
    return
21531 
 
21532 
 
21533 
  def __repr__(self):
21534 
    L = ['%s=%r' % (key, value)
21535 
      for key, value in self.__dict__.iteritems()]
21536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21537 
 
21538 
  def __eq__(self, other):
21539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21540 
 
21541 
  def __ne__(self, other):
21542 
    return not (self == other)
21543 
 
21544 
class getOrdersWhereVendorNotPaid_result:
21545 
  """
21546 
  Attributes:
21547 
   - success
21548 
   - ex
21549 
  """
21550 
 
21551 
  thrift_spec = (
21552 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21553 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21554 
  )
21555 
 
21556 
  def __init__(self, success=None, ex=None,):
21557 
    self.success = success
21558 
    self.ex = ex
21559 
 
21560 
  def read(self, iprot):
21561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21563 
      return
21564 
    iprot.readStructBegin()
21565 
    while True:
21566 
      (fname, ftype, fid) = iprot.readFieldBegin()
21567 
      if ftype == TType.STOP:
21568 
        break
21569 
      if fid == 0:
21570 
        if ftype == TType.LIST:
21571 
          self.success = []
5031 varun.gupt 21572 
          (_etype504, _size501) = iprot.readListBegin()
21573 
          for _i505 in xrange(_size501):
21574 
            _elem506 = Order()
21575 
            _elem506.read(iprot)
21576 
            self.success.append(_elem506)
4875 varun.gupt 21577 
          iprot.readListEnd()
21578 
        else:
21579 
          iprot.skip(ftype)
21580 
      elif fid == 1:
21581 
        if ftype == TType.STRUCT:
21582 
          self.ex = TransactionServiceException()
21583 
          self.ex.read(iprot)
21584 
        else:
21585 
          iprot.skip(ftype)
21586 
      else:
21587 
        iprot.skip(ftype)
21588 
      iprot.readFieldEnd()
21589 
    iprot.readStructEnd()
21590 
 
21591 
  def write(self, oprot):
21592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21594 
      return
21595 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_result')
21596 
    if self.success is not None:
21597 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21598 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 21599 
      for iter507 in self.success:
21600 
        iter507.write(oprot)
4875 varun.gupt 21601 
      oprot.writeListEnd()
21602 
      oprot.writeFieldEnd()
21603 
    if self.ex is not None:
21604 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21605 
      self.ex.write(oprot)
21606 
      oprot.writeFieldEnd()
21607 
    oprot.writeFieldStop()
21608 
    oprot.writeStructEnd()
21609 
 
21610 
  def validate(self):
21611 
    return
21612 
 
21613 
 
21614 
  def __repr__(self):
21615 
    L = ['%s=%r' % (key, value)
21616 
      for key, value in self.__dict__.iteritems()]
21617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21618 
 
21619 
  def __eq__(self, other):
21620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21621 
 
21622 
  def __ne__(self, other):
21623 
    return not (self == other)
5031 varun.gupt 21624 
 
21625 
class getStatusDistributionOfOrders_args:
21626 
  """
21627 
  Attributes:
21628 
   - startDate
21629 
   - endDate
21630 
  """
21631 
 
21632 
  thrift_spec = (
21633 
    None, # 0
21634 
    (1, TType.I64, 'startDate', None, None, ), # 1
21635 
    (2, TType.I64, 'endDate', None, None, ), # 2
21636 
  )
21637 
 
21638 
  def __init__(self, startDate=None, endDate=None,):
21639 
    self.startDate = startDate
21640 
    self.endDate = endDate
21641 
 
21642 
  def read(self, iprot):
21643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21645 
      return
21646 
    iprot.readStructBegin()
21647 
    while True:
21648 
      (fname, ftype, fid) = iprot.readFieldBegin()
21649 
      if ftype == TType.STOP:
21650 
        break
21651 
      if fid == 1:
21652 
        if ftype == TType.I64:
21653 
          self.startDate = iprot.readI64();
21654 
        else:
21655 
          iprot.skip(ftype)
21656 
      elif fid == 2:
21657 
        if ftype == TType.I64:
21658 
          self.endDate = iprot.readI64();
21659 
        else:
21660 
          iprot.skip(ftype)
21661 
      else:
21662 
        iprot.skip(ftype)
21663 
      iprot.readFieldEnd()
21664 
    iprot.readStructEnd()
21665 
 
21666 
  def write(self, oprot):
21667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21669 
      return
21670 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
21671 
    if self.startDate is not None:
21672 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
21673 
      oprot.writeI64(self.startDate)
21674 
      oprot.writeFieldEnd()
21675 
    if self.endDate is not None:
21676 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
21677 
      oprot.writeI64(self.endDate)
21678 
      oprot.writeFieldEnd()
21679 
    oprot.writeFieldStop()
21680 
    oprot.writeStructEnd()
21681 
 
21682 
  def validate(self):
21683 
    return
21684 
 
21685 
 
21686 
  def __repr__(self):
21687 
    L = ['%s=%r' % (key, value)
21688 
      for key, value in self.__dict__.iteritems()]
21689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21690 
 
21691 
  def __eq__(self, other):
21692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21693 
 
21694 
  def __ne__(self, other):
21695 
    return not (self == other)
21696 
 
21697 
class getStatusDistributionOfOrders_result:
21698 
  """
21699 
  Attributes:
21700 
   - success
21701 
   - ex
21702 
  """
21703 
 
21704 
  thrift_spec = (
21705 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
21706 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21707 
  )
21708 
 
21709 
  def __init__(self, success=None, ex=None,):
21710 
    self.success = success
21711 
    self.ex = ex
21712 
 
21713 
  def read(self, iprot):
21714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21716 
      return
21717 
    iprot.readStructBegin()
21718 
    while True:
21719 
      (fname, ftype, fid) = iprot.readFieldBegin()
21720 
      if ftype == TType.STOP:
21721 
        break
21722 
      if fid == 0:
21723 
        if ftype == TType.MAP:
21724 
          self.success = {}
21725 
          (_ktype509, _vtype510, _size508 ) = iprot.readMapBegin()
21726 
          for _i512 in xrange(_size508):
21727 
            _key513 = iprot.readI64();
21728 
            _val514 = iprot.readI64();
21729 
            self.success[_key513] = _val514
21730 
          iprot.readMapEnd()
21731 
        else:
21732 
          iprot.skip(ftype)
21733 
      elif fid == 1:
21734 
        if ftype == TType.STRUCT:
21735 
          self.ex = TransactionServiceException()
21736 
          self.ex.read(iprot)
21737 
        else:
21738 
          iprot.skip(ftype)
21739 
      else:
21740 
        iprot.skip(ftype)
21741 
      iprot.readFieldEnd()
21742 
    iprot.readStructEnd()
21743 
 
21744 
  def write(self, oprot):
21745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21747 
      return
21748 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
21749 
    if self.success is not None:
21750 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21751 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
21752 
      for kiter515,viter516 in self.success.items():
21753 
        oprot.writeI64(kiter515)
21754 
        oprot.writeI64(viter516)
21755 
      oprot.writeMapEnd()
21756 
      oprot.writeFieldEnd()
21757 
    if self.ex is not None:
21758 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21759 
      self.ex.write(oprot)
21760 
      oprot.writeFieldEnd()
21761 
    oprot.writeFieldStop()
21762 
    oprot.writeStructEnd()
21763 
 
21764 
  def validate(self):
21765 
    return
21766 
 
21767 
 
21768 
  def __repr__(self):
21769 
    L = ['%s=%r' % (key, value)
21770 
      for key, value in self.__dict__.iteritems()]
21771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21772 
 
21773 
  def __eq__(self, other):
21774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21775 
 
21776 
  def __ne__(self, other):
21777 
    return not (self == other)
5067 varun.gupt 21778 
 
21779 
class getOrderIdsForStatus_args:
21780 
  """
21781 
  Attributes:
21782 
   - status
21783 
   - startDatetime
21784 
   - endDatetime
21785 
  """
21786 
 
21787 
  thrift_spec = (
21788 
    None, # 0
21789 
    (1, TType.I64, 'status', None, None, ), # 1
21790 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
21791 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
21792 
  )
21793 
 
21794 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
21795 
    self.status = status
21796 
    self.startDatetime = startDatetime
21797 
    self.endDatetime = endDatetime
21798 
 
21799 
  def read(self, iprot):
21800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21802 
      return
21803 
    iprot.readStructBegin()
21804 
    while True:
21805 
      (fname, ftype, fid) = iprot.readFieldBegin()
21806 
      if ftype == TType.STOP:
21807 
        break
21808 
      if fid == 1:
21809 
        if ftype == TType.I64:
21810 
          self.status = iprot.readI64();
21811 
        else:
21812 
          iprot.skip(ftype)
21813 
      elif fid == 2:
21814 
        if ftype == TType.I64:
21815 
          self.startDatetime = iprot.readI64();
21816 
        else:
21817 
          iprot.skip(ftype)
21818 
      elif fid == 3:
21819 
        if ftype == TType.I64:
21820 
          self.endDatetime = iprot.readI64();
21821 
        else:
21822 
          iprot.skip(ftype)
21823 
      else:
21824 
        iprot.skip(ftype)
21825 
      iprot.readFieldEnd()
21826 
    iprot.readStructEnd()
21827 
 
21828 
  def write(self, oprot):
21829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21831 
      return
21832 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
21833 
    if self.status is not None:
21834 
      oprot.writeFieldBegin('status', TType.I64, 1)
21835 
      oprot.writeI64(self.status)
21836 
      oprot.writeFieldEnd()
21837 
    if self.startDatetime is not None:
21838 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
21839 
      oprot.writeI64(self.startDatetime)
21840 
      oprot.writeFieldEnd()
21841 
    if self.endDatetime is not None:
21842 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
21843 
      oprot.writeI64(self.endDatetime)
21844 
      oprot.writeFieldEnd()
21845 
    oprot.writeFieldStop()
21846 
    oprot.writeStructEnd()
21847 
 
21848 
  def validate(self):
21849 
    return
21850 
 
21851 
 
21852 
  def __repr__(self):
21853 
    L = ['%s=%r' % (key, value)
21854 
      for key, value in self.__dict__.iteritems()]
21855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21856 
 
21857 
  def __eq__(self, other):
21858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21859 
 
21860 
  def __ne__(self, other):
21861 
    return not (self == other)
21862 
 
21863 
class getOrderIdsForStatus_result:
21864 
  """
21865 
  Attributes:
21866 
   - success
21867 
   - ex
21868 
  """
21869 
 
21870 
  thrift_spec = (
21871 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21872 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21873 
  )
21874 
 
21875 
  def __init__(self, success=None, ex=None,):
21876 
    self.success = success
21877 
    self.ex = ex
21878 
 
21879 
  def read(self, iprot):
21880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21882 
      return
21883 
    iprot.readStructBegin()
21884 
    while True:
21885 
      (fname, ftype, fid) = iprot.readFieldBegin()
21886 
      if ftype == TType.STOP:
21887 
        break
21888 
      if fid == 0:
21889 
        if ftype == TType.LIST:
21890 
          self.success = []
21891 
          (_etype520, _size517) = iprot.readListBegin()
21892 
          for _i521 in xrange(_size517):
21893 
            _elem522 = iprot.readI64();
21894 
            self.success.append(_elem522)
21895 
          iprot.readListEnd()
21896 
        else:
21897 
          iprot.skip(ftype)
21898 
      elif fid == 1:
21899 
        if ftype == TType.STRUCT:
21900 
          self.ex = TransactionServiceException()
21901 
          self.ex.read(iprot)
21902 
        else:
21903 
          iprot.skip(ftype)
21904 
      else:
21905 
        iprot.skip(ftype)
21906 
      iprot.readFieldEnd()
21907 
    iprot.readStructEnd()
21908 
 
21909 
  def write(self, oprot):
21910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21912 
      return
21913 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
21914 
    if self.success is not None:
21915 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21916 
      oprot.writeListBegin(TType.I64, len(self.success))
21917 
      for iter523 in self.success:
21918 
        oprot.writeI64(iter523)
21919 
      oprot.writeListEnd()
21920 
      oprot.writeFieldEnd()
21921 
    if self.ex is not None:
21922 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21923 
      self.ex.write(oprot)
21924 
      oprot.writeFieldEnd()
21925 
    oprot.writeFieldStop()
21926 
    oprot.writeStructEnd()
21927 
 
21928 
  def validate(self):
21929 
    return
21930 
 
21931 
 
21932 
  def __repr__(self):
21933 
    L = ['%s=%r' % (key, value)
21934 
      for key, value in self.__dict__.iteritems()]
21935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21936 
 
21937 
  def __eq__(self, other):
21938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21939 
 
21940 
  def __ne__(self, other):
21941 
    return not (self == other)