Subversion Repositories SmartDukaan

Rev

Rev 5238 | Rev 5382 | 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 
 
5110 mandeep.dh 325 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, 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
5110 mandeep.dh 342 
     - fulfilmentWarehouseId
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 
 
5189 varun.gupt 1046 
  def getSettlementForReferenceId(self, referenceId, isRefund):
4600 varun.gupt 1047 
    """
1048 
    Parameters:
5189 varun.gupt 1049 
     - referenceId
1050 
     - isRefund
4600 varun.gupt 1051 
    """
1052 
    pass
1053 
 
1054 
  def getEBSSettlementSummaries(self, ):
1055 
    pass
1056 
 
1057 
  def markEBSSettlementUploaded(self, settlementId):
1058 
    """
1059 
    Parameters:
1060 
     - settlementId
1061 
    """
1062 
    pass
1063 
 
1064 
  def getEBSSettlementDate(self, settlementId):
1065 
    """
1066 
    Parameters:
1067 
     - settlementId
1068 
    """
1069 
    pass
1070 
 
4715 varun.gupt 1071 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1072 
    """
1073 
    Parameters:
1074 
     - settlementDateFrom
1075 
     - settlementDateTo
1076 
     - isRefund
1077 
    """
1078 
    pass
4600 varun.gupt 1079 
 
4715 varun.gupt 1080 
  def getReshippedOrderIds(self, orderIds):
1081 
    """
1082 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1083 
 
1084 
    Parameters:
1085 
     - orderIds
1086 
    """
1087 
    pass
1088 
 
5348 anupam.sin 1089 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
1090 
    """
1091 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
1092 
    the quantities for which the PO is raised.
1093 
 
1094 
    Parameters:
1095 
     - itemIdQuantityMap
1096 
     - purchaseOrderId
1097 
     - warehouseId
1098 
    """
1099 
    pass
1100 
 
4875 varun.gupt 1101 
  def getOrdersWhereVendorNotPaid(self, vendorId):
1102 
    """
1103 
    Parameters:
1104 
     - vendorId
1105 
    """
1106 
    pass
4757 mandeep.dh 1107 
 
5031 varun.gupt 1108 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1109 
    """
1110 
    Parameters:
1111 
     - startDate
1112 
     - endDate
1113 
    """
1114 
    pass
4875 varun.gupt 1115 
 
5067 varun.gupt 1116 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1117 
    """
1118 
    Parameters:
1119 
     - status
1120 
     - startDatetime
1121 
     - endDatetime
1122 
    """
1123 
    pass
5031 varun.gupt 1124 
 
5348 anupam.sin 1125 
  def updateCODAgent(self, agent, orderId):
1126 
    """
1127 
    Updates the agent who handled the COD verification call
1128 
 
1129 
    Parameters:
1130 
     - agent
1131 
     - orderId
1132 
    """
1133 
    pass
1134 
 
5099 varun.gupt 1135 
  def updateOrderAsPaidToVendor(self, orderId):
1136 
    """
1137 
    Parameters:
1138 
     - orderId
1139 
    """
1140 
    pass
5067 varun.gupt 1141 
 
5208 varun.gupt 1142 
  def getRefundedOrdersMarkedPaid(self, ):
1143 
    pass
5099 varun.gupt 1144 
 
5208 varun.gupt 1145 
 
3376 rajveer 1146 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1147 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1148 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1149 
 
1150 
  def createTransaction(self, transaction):
1151 
    """
1152 
    Parameters:
1153 
     - transaction
1154 
    """
1155 
    self.send_createTransaction(transaction)
132 ashish 1156 
    return self.recv_createTransaction()
94 ashish 1157 
 
1158 
  def send_createTransaction(self, transaction):
1159 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1160 
    args = createTransaction_args()
1161 
    args.transaction = transaction
1162 
    args.write(self._oprot)
1163 
    self._oprot.writeMessageEnd()
1164 
    self._oprot.trans.flush()
1165 
 
1166 
  def recv_createTransaction(self, ):
1167 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1168 
    if mtype == TMessageType.EXCEPTION:
1169 
      x = TApplicationException()
1170 
      x.read(self._iprot)
1171 
      self._iprot.readMessageEnd()
1172 
      raise x
1173 
    result = createTransaction_result()
1174 
    result.read(self._iprot)
1175 
    self._iprot.readMessageEnd()
3431 rajveer 1176 
    if result.success is not None:
132 ashish 1177 
      return result.success
3431 rajveer 1178 
    if result.ex is not None:
94 ashish 1179 
      raise result.ex
132 ashish 1180 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1181 
 
1182 
  def getTransaction(self, id):
1183 
    """
1184 
    Parameters:
1185 
     - id
1186 
    """
1187 
    self.send_getTransaction(id)
1188 
    return self.recv_getTransaction()
1189 
 
1190 
  def send_getTransaction(self, id):
1191 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1192 
    args = getTransaction_args()
1193 
    args.id = id
1194 
    args.write(self._oprot)
1195 
    self._oprot.writeMessageEnd()
1196 
    self._oprot.trans.flush()
1197 
 
1198 
  def recv_getTransaction(self, ):
1199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1200 
    if mtype == TMessageType.EXCEPTION:
1201 
      x = TApplicationException()
1202 
      x.read(self._iprot)
1203 
      self._iprot.readMessageEnd()
1204 
      raise x
1205 
    result = getTransaction_result()
1206 
    result.read(self._iprot)
1207 
    self._iprot.readMessageEnd()
3431 rajveer 1208 
    if result.success is not None:
94 ashish 1209 
      return result.success
3431 rajveer 1210 
    if result.ex is not None:
94 ashish 1211 
      raise result.ex
1212 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1213 
 
1214 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1215 
    """
1216 
    Parameters:
1217 
     - customerId
1218 
     - from_date
1219 
     - to_date
1220 
     - status
1221 
    """
1222 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1223 
    return self.recv_getTransactionsForCustomer()
1224 
 
1225 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1226 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1227 
    args = getTransactionsForCustomer_args()
1228 
    args.customerId = customerId
1229 
    args.from_date = from_date
1230 
    args.to_date = to_date
1231 
    args.status = status
1232 
    args.write(self._oprot)
1233 
    self._oprot.writeMessageEnd()
1234 
    self._oprot.trans.flush()
1235 
 
1236 
  def recv_getTransactionsForCustomer(self, ):
1237 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1238 
    if mtype == TMessageType.EXCEPTION:
1239 
      x = TApplicationException()
1240 
      x.read(self._iprot)
1241 
      self._iprot.readMessageEnd()
1242 
      raise x
1243 
    result = getTransactionsForCustomer_result()
1244 
    result.read(self._iprot)
1245 
    self._iprot.readMessageEnd()
3431 rajveer 1246 
    if result.success is not None:
94 ashish 1247 
      return result.success
3431 rajveer 1248 
    if result.ex is not None:
94 ashish 1249 
      raise result.ex
1250 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1251 
 
132 ashish 1252 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1253 
    """
1254 
    Parameters:
1255 
     - shoppingCartId
1256 
    """
1257 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1258 
    return self.recv_getTransactionsForShoppingCartId()
1259 
 
1260 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1261 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1262 
    args = getTransactionsForShoppingCartId_args()
1263 
    args.shoppingCartId = shoppingCartId
1264 
    args.write(self._oprot)
1265 
    self._oprot.writeMessageEnd()
1266 
    self._oprot.trans.flush()
1267 
 
1268 
  def recv_getTransactionsForShoppingCartId(self, ):
1269 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1270 
    if mtype == TMessageType.EXCEPTION:
1271 
      x = TApplicationException()
1272 
      x.read(self._iprot)
1273 
      self._iprot.readMessageEnd()
1274 
      raise x
1275 
    result = getTransactionsForShoppingCartId_result()
1276 
    result.read(self._iprot)
1277 
    self._iprot.readMessageEnd()
3431 rajveer 1278 
    if result.success is not None:
132 ashish 1279 
      return result.success
3431 rajveer 1280 
    if result.ex is not None:
132 ashish 1281 
      raise result.ex
1282 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1283 
 
94 ashish 1284 
  def getTransactionStatus(self, transactionId):
1285 
    """
1286 
    Parameters:
1287 
     - transactionId
1288 
    """
1289 
    self.send_getTransactionStatus(transactionId)
1290 
    return self.recv_getTransactionStatus()
1291 
 
1292 
  def send_getTransactionStatus(self, transactionId):
1293 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1294 
    args = getTransactionStatus_args()
1295 
    args.transactionId = transactionId
1296 
    args.write(self._oprot)
1297 
    self._oprot.writeMessageEnd()
1298 
    self._oprot.trans.flush()
1299 
 
1300 
  def recv_getTransactionStatus(self, ):
1301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1302 
    if mtype == TMessageType.EXCEPTION:
1303 
      x = TApplicationException()
1304 
      x.read(self._iprot)
1305 
      self._iprot.readMessageEnd()
1306 
      raise x
1307 
    result = getTransactionStatus_result()
1308 
    result.read(self._iprot)
1309 
    self._iprot.readMessageEnd()
3431 rajveer 1310 
    if result.success is not None:
94 ashish 1311 
      return result.success
3431 rajveer 1312 
    if result.ex is not None:
94 ashish 1313 
      raise result.ex
1314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1315 
 
1316 
  def changeTransactionStatus(self, transactionId, status, description):
1317 
    """
1318 
    Parameters:
1319 
     - transactionId
1320 
     - status
1321 
     - description
1322 
    """
1323 
    self.send_changeTransactionStatus(transactionId, status, description)
1324 
    return self.recv_changeTransactionStatus()
1325 
 
1326 
  def send_changeTransactionStatus(self, transactionId, status, description):
1327 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1328 
    args = changeTransactionStatus_args()
1329 
    args.transactionId = transactionId
1330 
    args.status = status
1331 
    args.description = description
1332 
    args.write(self._oprot)
1333 
    self._oprot.writeMessageEnd()
1334 
    self._oprot.trans.flush()
1335 
 
1336 
  def recv_changeTransactionStatus(self, ):
1337 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1338 
    if mtype == TMessageType.EXCEPTION:
1339 
      x = TApplicationException()
1340 
      x.read(self._iprot)
1341 
      self._iprot.readMessageEnd()
1342 
      raise x
1343 
    result = changeTransactionStatus_result()
1344 
    result.read(self._iprot)
1345 
    self._iprot.readMessageEnd()
3431 rajveer 1346 
    if result.success is not None:
94 ashish 1347 
      return result.success
3431 rajveer 1348 
    if result.ex is not None:
94 ashish 1349 
      raise result.ex
1350 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1351 
 
1398 varun.gupt 1352 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1353 
    """
1354 
    Parameters:
1355 
     - transactionId
1356 
    """
1398 varun.gupt 1357 
    self.send_enqueueTransactionInfoEmail(transactionId)
1358 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1359 
 
1398 varun.gupt 1360 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1361 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1362 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1363 
    args.transactionId = transactionId
1364 
    args.write(self._oprot)
1365 
    self._oprot.writeMessageEnd()
1366 
    self._oprot.trans.flush()
1367 
 
1398 varun.gupt 1368 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1370 
    if mtype == TMessageType.EXCEPTION:
1371 
      x = TApplicationException()
1372 
      x.read(self._iprot)
1373 
      self._iprot.readMessageEnd()
1374 
      raise x
1398 varun.gupt 1375 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1376 
    result.read(self._iprot)
1377 
    self._iprot.readMessageEnd()
3431 rajveer 1378 
    if result.success is not None:
1382 varun.gupt 1379 
      return result.success
3431 rajveer 1380 
    if result.ex is not None:
1382 varun.gupt 1381 
      raise result.ex
1398 varun.gupt 1382 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1383 
 
4801 anupam.sin 1384 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1385 
    """
1386 
    Parameters:
4801 anupam.sin 1387 
     - statuses
483 rajveer 1388 
     - from_date
1389 
     - to_date
1390 
     - warehouse_id
94 ashish 1391 
    """
4801 anupam.sin 1392 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1393 
    return self.recv_getAllOrders()
94 ashish 1394 
 
4801 anupam.sin 1395 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1396 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1397 
    args = getAllOrders_args()
4801 anupam.sin 1398 
    args.statuses = statuses
483 rajveer 1399 
    args.from_date = from_date
1400 
    args.to_date = to_date
1401 
    args.warehouse_id = warehouse_id
94 ashish 1402 
    args.write(self._oprot)
1403 
    self._oprot.writeMessageEnd()
1404 
    self._oprot.trans.flush()
1405 
 
483 rajveer 1406 
  def recv_getAllOrders(self, ):
94 ashish 1407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1408 
    if mtype == TMessageType.EXCEPTION:
1409 
      x = TApplicationException()
1410 
      x.read(self._iprot)
1411 
      self._iprot.readMessageEnd()
1412 
      raise x
483 rajveer 1413 
    result = getAllOrders_result()
94 ashish 1414 
    result.read(self._iprot)
1415 
    self._iprot.readMessageEnd()
3431 rajveer 1416 
    if result.success is not None:
94 ashish 1417 
      return result.success
3431 rajveer 1418 
    if result.ex is not None:
94 ashish 1419 
      raise result.ex
483 rajveer 1420 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1421 
 
4133 chandransh 1422 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1423 
    """
1424 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1425 
    Pass the status as null and the limit as 0 to ignore them.
1426 
 
1427 
    Parameters:
1428 
     - statuses
1429 
     - offset
1430 
     - limit
1431 
     - warehouse_id
1432 
    """
1433 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1434 
    return self.recv_getOrdersInBatch()
1435 
 
1436 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1437 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1438 
    args = getOrdersInBatch_args()
1439 
    args.statuses = statuses
1440 
    args.offset = offset
1441 
    args.limit = limit
1442 
    args.warehouse_id = warehouse_id
1443 
    args.write(self._oprot)
1444 
    self._oprot.writeMessageEnd()
1445 
    self._oprot.trans.flush()
1446 
 
1447 
  def recv_getOrdersInBatch(self, ):
1448 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1449 
    if mtype == TMessageType.EXCEPTION:
1450 
      x = TApplicationException()
1451 
      x.read(self._iprot)
1452 
      self._iprot.readMessageEnd()
1453 
      raise x
1454 
    result = getOrdersInBatch_result()
1455 
    result.read(self._iprot)
1456 
    self._iprot.readMessageEnd()
1457 
    if result.success is not None:
1458 
      return result.success
1459 
    if result.ex is not None:
1460 
      raise result.ex
1461 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1462 
 
1463 
  def getOrderCount(self, statuses, warehouseId):
1464 
    """
1465 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1466 
 
1467 
    Parameters:
1468 
     - statuses
1469 
     - warehouseId
1470 
    """
1471 
    self.send_getOrderCount(statuses, warehouseId)
1472 
    return self.recv_getOrderCount()
1473 
 
1474 
  def send_getOrderCount(self, statuses, warehouseId):
1475 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1476 
    args = getOrderCount_args()
1477 
    args.statuses = statuses
1478 
    args.warehouseId = warehouseId
1479 
    args.write(self._oprot)
1480 
    self._oprot.writeMessageEnd()
1481 
    self._oprot.trans.flush()
1482 
 
1483 
  def recv_getOrderCount(self, ):
1484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1485 
    if mtype == TMessageType.EXCEPTION:
1486 
      x = TApplicationException()
1487 
      x.read(self._iprot)
1488 
      self._iprot.readMessageEnd()
1489 
      raise x
1490 
    result = getOrderCount_result()
1491 
    result.read(self._iprot)
1492 
    self._iprot.readMessageEnd()
1493 
    if result.success is not None:
1494 
      return result.success
1495 
    if result.ex is not None:
1496 
      raise result.ex
1497 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1498 
 
999 varun.gupt 1499 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1500 
    """
1132 chandransh 1501 
    Returns orders within a range of their billing dates
3431 rajveer 1502 
 
999 varun.gupt 1503 
    Parameters:
1504 
     - status
1505 
     - start_billing_date
1506 
     - end_billing_date
1507 
     - warehouse_id
1508 
    """
1509 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1510 
    return self.recv_getOrdersByBillingDate()
1511 
 
1512 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1513 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1514 
    args = getOrdersByBillingDate_args()
1515 
    args.status = status
1516 
    args.start_billing_date = start_billing_date
1517 
    args.end_billing_date = end_billing_date
1518 
    args.warehouse_id = warehouse_id
1519 
    args.write(self._oprot)
1520 
    self._oprot.writeMessageEnd()
1521 
    self._oprot.trans.flush()
1522 
 
1523 
  def recv_getOrdersByBillingDate(self, ):
1524 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1525 
    if mtype == TMessageType.EXCEPTION:
1526 
      x = TApplicationException()
1527 
      x.read(self._iprot)
1528 
      self._iprot.readMessageEnd()
1529 
      raise x
1530 
    result = getOrdersByBillingDate_result()
1531 
    result.read(self._iprot)
1532 
    self._iprot.readMessageEnd()
3431 rajveer 1533 
    if result.success is not None:
999 varun.gupt 1534 
      return result.success
3431 rajveer 1535 
    if result.ex is not None:
999 varun.gupt 1536 
      raise result.ex
1537 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1538 
 
3451 chandransh 1539 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1540 
    """
1541 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1542 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1543 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1544 
 
3427 chandransh 1545 
    Parameters:
1546 
     - fromShippingDate
1547 
     - toShippingDate
1548 
     - providerId
1549 
     - warehouseId
3451 chandransh 1550 
     - cod
3427 chandransh 1551 
    """
3451 chandransh 1552 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1553 
    return self.recv_getOrdersByShippingDate()
1554 
 
3451 chandransh 1555 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1556 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1557 
    args = getOrdersByShippingDate_args()
1558 
    args.fromShippingDate = fromShippingDate
1559 
    args.toShippingDate = toShippingDate
1560 
    args.providerId = providerId
1561 
    args.warehouseId = warehouseId
3451 chandransh 1562 
    args.cod = cod
3427 chandransh 1563 
    args.write(self._oprot)
1564 
    self._oprot.writeMessageEnd()
1565 
    self._oprot.trans.flush()
1566 
 
1567 
  def recv_getOrdersByShippingDate(self, ):
1568 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1569 
    if mtype == TMessageType.EXCEPTION:
1570 
      x = TApplicationException()
1571 
      x.read(self._iprot)
1572 
      self._iprot.readMessageEnd()
1573 
      raise x
1574 
    result = getOrdersByShippingDate_result()
1575 
    result.read(self._iprot)
1576 
    self._iprot.readMessageEnd()
3431 rajveer 1577 
    if result.success is not None:
3427 chandransh 1578 
      return result.success
3431 rajveer 1579 
    if result.ex is not None:
3427 chandransh 1580 
      raise result.ex
1581 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1582 
 
1382 varun.gupt 1583 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1584 
    """
1585 
    Returns order ids for orders which can be returned
3431 rajveer 1586 
 
1382 varun.gupt 1587 
    Parameters:
1588 
     - customer_id
1589 
     - limit
1590 
    """
1591 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1592 
    return self.recv_getReturnableOrdersForCustomer()
1593 
 
1594 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1595 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1596 
    args = getReturnableOrdersForCustomer_args()
1597 
    args.customer_id = customer_id
1598 
    args.limit = limit
1599 
    args.write(self._oprot)
1600 
    self._oprot.writeMessageEnd()
1601 
    self._oprot.trans.flush()
1602 
 
1603 
  def recv_getReturnableOrdersForCustomer(self, ):
1604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1605 
    if mtype == TMessageType.EXCEPTION:
1606 
      x = TApplicationException()
1607 
      x.read(self._iprot)
1608 
      self._iprot.readMessageEnd()
1609 
      raise x
1610 
    result = getReturnableOrdersForCustomer_result()
1611 
    result.read(self._iprot)
1612 
    self._iprot.readMessageEnd()
3431 rajveer 1613 
    if result.success is not None:
1382 varun.gupt 1614 
      return result.success
3431 rajveer 1615 
    if result.ex is not None:
1382 varun.gupt 1616 
      raise result.ex
1617 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1618 
 
1619 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1620 
    """
1621 
    Returns order ids for orders which can be cancelled
3431 rajveer 1622 
 
1382 varun.gupt 1623 
    Parameters:
1624 
     - customer_id
1625 
     - limit
1626 
    """
1627 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1628 
    return self.recv_getCancellableOrdersForCustomer()
1629 
 
1630 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1631 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1632 
    args = getCancellableOrdersForCustomer_args()
1633 
    args.customer_id = customer_id
1634 
    args.limit = limit
1635 
    args.write(self._oprot)
1636 
    self._oprot.writeMessageEnd()
1637 
    self._oprot.trans.flush()
1638 
 
1639 
  def recv_getCancellableOrdersForCustomer(self, ):
1640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1641 
    if mtype == TMessageType.EXCEPTION:
1642 
      x = TApplicationException()
1643 
      x.read(self._iprot)
1644 
      self._iprot.readMessageEnd()
1645 
      raise x
1646 
    result = getCancellableOrdersForCustomer_result()
1647 
    result.read(self._iprot)
1648 
    self._iprot.readMessageEnd()
3431 rajveer 1649 
    if result.success is not None:
1382 varun.gupt 1650 
      return result.success
3431 rajveer 1651 
    if result.ex is not None:
1382 varun.gupt 1652 
      raise result.ex
1653 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1654 
 
483 rajveer 1655 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1656 
    """
1657 
    Parameters:
483 rajveer 1658 
     - orderId
1659 
     - status
1660 
     - description
94 ashish 1661 
    """
483 rajveer 1662 
    self.send_changeOrderStatus(orderId, status, description)
1663 
    return self.recv_changeOrderStatus()
94 ashish 1664 
 
483 rajveer 1665 
  def send_changeOrderStatus(self, orderId, status, description):
1666 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1667 
    args = changeOrderStatus_args()
1668 
    args.orderId = orderId
1669 
    args.status = status
1670 
    args.description = description
94 ashish 1671 
    args.write(self._oprot)
1672 
    self._oprot.writeMessageEnd()
1673 
    self._oprot.trans.flush()
1674 
 
483 rajveer 1675 
  def recv_changeOrderStatus(self, ):
94 ashish 1676 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1677 
    if mtype == TMessageType.EXCEPTION:
1678 
      x = TApplicationException()
1679 
      x.read(self._iprot)
1680 
      self._iprot.readMessageEnd()
1681 
      raise x
483 rajveer 1682 
    result = changeOrderStatus_result()
94 ashish 1683 
    result.read(self._iprot)
1684 
    self._iprot.readMessageEnd()
3431 rajveer 1685 
    if result.success is not None:
94 ashish 1686 
      return result.success
3431 rajveer 1687 
    if result.ex is not None:
94 ashish 1688 
      raise result.ex
483 rajveer 1689 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1690 
 
1528 ankur.sing 1691 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1692 
    """
1528 ankur.sing 1693 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1694 
    only user who owns the transaction can view its order details.
3431 rajveer 1695 
 
94 ashish 1696 
    Parameters:
1697 
     - transactionId
1528 ankur.sing 1698 
     - customerId
94 ashish 1699 
    """
1528 ankur.sing 1700 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1701 
    return self.recv_getOrdersForTransaction()
94 ashish 1702 
 
1528 ankur.sing 1703 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1704 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1705 
    args = getOrdersForTransaction_args()
94 ashish 1706 
    args.transactionId = transactionId
1528 ankur.sing 1707 
    args.customerId = customerId
94 ashish 1708 
    args.write(self._oprot)
1709 
    self._oprot.writeMessageEnd()
1710 
    self._oprot.trans.flush()
1711 
 
483 rajveer 1712 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1714 
    if mtype == TMessageType.EXCEPTION:
1715 
      x = TApplicationException()
1716 
      x.read(self._iprot)
1717 
      self._iprot.readMessageEnd()
1718 
      raise x
483 rajveer 1719 
    result = getOrdersForTransaction_result()
94 ashish 1720 
    result.read(self._iprot)
1721 
    self._iprot.readMessageEnd()
3431 rajveer 1722 
    if result.success is not None:
94 ashish 1723 
      return result.success
3431 rajveer 1724 
    if result.ex is not None:
94 ashish 1725 
      raise result.ex
483 rajveer 1726 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1727 
 
3014 chandransh 1728 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1729 
    """
3014 chandransh 1730 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1731 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1732 
 
94 ashish 1733 
    Parameters:
483 rajveer 1734 
     - customerId
1735 
     - from_date
1736 
     - to_date
3014 chandransh 1737 
     - statuses
94 ashish 1738 
    """
3014 chandransh 1739 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1740 
    return self.recv_getOrdersForCustomer()
94 ashish 1741 
 
3014 chandransh 1742 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1743 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1744 
    args = getOrdersForCustomer_args()
1745 
    args.customerId = customerId
1746 
    args.from_date = from_date
1747 
    args.to_date = to_date
3014 chandransh 1748 
    args.statuses = statuses
94 ashish 1749 
    args.write(self._oprot)
1750 
    self._oprot.writeMessageEnd()
1751 
    self._oprot.trans.flush()
1752 
 
483 rajveer 1753 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1755 
    if mtype == TMessageType.EXCEPTION:
1756 
      x = TApplicationException()
1757 
      x.read(self._iprot)
1758 
      self._iprot.readMessageEnd()
1759 
      raise x
483 rajveer 1760 
    result = getOrdersForCustomer_result()
94 ashish 1761 
    result.read(self._iprot)
1762 
    self._iprot.readMessageEnd()
3431 rajveer 1763 
    if result.success is not None:
94 ashish 1764 
      return result.success
3431 rajveer 1765 
    if result.ex is not None:
94 ashish 1766 
      raise result.ex
483 rajveer 1767 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1768 
 
483 rajveer 1769 
  def createOrder(self, order):
94 ashish 1770 
    """
1771 
    Parameters:
483 rajveer 1772 
     - order
94 ashish 1773 
    """
483 rajveer 1774 
    self.send_createOrder(order)
1775 
    return self.recv_createOrder()
94 ashish 1776 
 
483 rajveer 1777 
  def send_createOrder(self, order):
1778 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1779 
    args = createOrder_args()
1780 
    args.order = order
94 ashish 1781 
    args.write(self._oprot)
1782 
    self._oprot.writeMessageEnd()
1783 
    self._oprot.trans.flush()
1784 
 
483 rajveer 1785 
  def recv_createOrder(self, ):
94 ashish 1786 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1787 
    if mtype == TMessageType.EXCEPTION:
1788 
      x = TApplicationException()
1789 
      x.read(self._iprot)
1790 
      self._iprot.readMessageEnd()
1791 
      raise x
483 rajveer 1792 
    result = createOrder_result()
94 ashish 1793 
    result.read(self._iprot)
1794 
    self._iprot.readMessageEnd()
3431 rajveer 1795 
    if result.success is not None:
94 ashish 1796 
      return result.success
3431 rajveer 1797 
    if result.ex is not None:
94 ashish 1798 
      raise result.ex
483 rajveer 1799 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1800 
 
483 rajveer 1801 
  def getOrder(self, id):
94 ashish 1802 
    """
1803 
    Parameters:
483 rajveer 1804 
     - id
94 ashish 1805 
    """
483 rajveer 1806 
    self.send_getOrder(id)
1807 
    return self.recv_getOrder()
94 ashish 1808 
 
483 rajveer 1809 
  def send_getOrder(self, id):
1810 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1811 
    args = getOrder_args()
1812 
    args.id = id
94 ashish 1813 
    args.write(self._oprot)
1814 
    self._oprot.writeMessageEnd()
1815 
    self._oprot.trans.flush()
1816 
 
483 rajveer 1817 
  def recv_getOrder(self, ):
94 ashish 1818 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1819 
    if mtype == TMessageType.EXCEPTION:
1820 
      x = TApplicationException()
1821 
      x.read(self._iprot)
1822 
      self._iprot.readMessageEnd()
1823 
      raise x
483 rajveer 1824 
    result = getOrder_result()
94 ashish 1825 
    result.read(self._iprot)
1826 
    self._iprot.readMessageEnd()
3431 rajveer 1827 
    if result.success is not None:
94 ashish 1828 
      return result.success
3431 rajveer 1829 
    if result.ex is not None:
94 ashish 1830 
      raise result.ex
483 rajveer 1831 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1832 
 
483 rajveer 1833 
  def getLineItemsForOrder(self, orderId):
94 ashish 1834 
    """
1835 
    Parameters:
483 rajveer 1836 
     - orderId
94 ashish 1837 
    """
483 rajveer 1838 
    self.send_getLineItemsForOrder(orderId)
1839 
    return self.recv_getLineItemsForOrder()
94 ashish 1840 
 
483 rajveer 1841 
  def send_getLineItemsForOrder(self, orderId):
1842 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1843 
    args = getLineItemsForOrder_args()
1844 
    args.orderId = orderId
94 ashish 1845 
    args.write(self._oprot)
1846 
    self._oprot.writeMessageEnd()
1847 
    self._oprot.trans.flush()
1848 
 
483 rajveer 1849 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1850 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1851 
    if mtype == TMessageType.EXCEPTION:
1852 
      x = TApplicationException()
1853 
      x.read(self._iprot)
1854 
      self._iprot.readMessageEnd()
1855 
      raise x
483 rajveer 1856 
    result = getLineItemsForOrder_result()
94 ashish 1857 
    result.read(self._iprot)
1858 
    self._iprot.readMessageEnd()
3431 rajveer 1859 
    if result.success is not None:
94 ashish 1860 
      return result.success
3431 rajveer 1861 
    if result.ex is not None:
94 ashish 1862 
      raise result.ex
483 rajveer 1863 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1864 
 
4999 phani.kuma 1865 
  def getOrderList(self, order_ids):
1866 
    """
1867 
    Parameters:
1868 
     - order_ids
1869 
    """
1870 
    self.send_getOrderList(order_ids)
1871 
    return self.recv_getOrderList()
1872 
 
1873 
  def send_getOrderList(self, order_ids):
1874 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
1875 
    args = getOrderList_args()
1876 
    args.order_ids = order_ids
1877 
    args.write(self._oprot)
1878 
    self._oprot.writeMessageEnd()
1879 
    self._oprot.trans.flush()
1880 
 
1881 
  def recv_getOrderList(self, ):
1882 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1883 
    if mtype == TMessageType.EXCEPTION:
1884 
      x = TApplicationException()
1885 
      x.read(self._iprot)
1886 
      self._iprot.readMessageEnd()
1887 
      raise x
1888 
    result = getOrderList_result()
1889 
    result.read(self._iprot)
1890 
    self._iprot.readMessageEnd()
1891 
    if result.success is not None:
1892 
      return result.success
1893 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
1894 
 
1528 ankur.sing 1895 
  def getOrderForCustomer(self, orderId, customerId):
1896 
    """
1897 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1898 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1899 
 
1528 ankur.sing 1900 
    Parameters:
1901 
     - orderId
1902 
     - customerId
1903 
    """
1904 
    self.send_getOrderForCustomer(orderId, customerId)
1905 
    return self.recv_getOrderForCustomer()
1906 
 
1907 
  def send_getOrderForCustomer(self, orderId, customerId):
1908 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1909 
    args = getOrderForCustomer_args()
1910 
    args.orderId = orderId
1911 
    args.customerId = customerId
1912 
    args.write(self._oprot)
1913 
    self._oprot.writeMessageEnd()
1914 
    self._oprot.trans.flush()
1915 
 
1916 
  def recv_getOrderForCustomer(self, ):
1917 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1918 
    if mtype == TMessageType.EXCEPTION:
1919 
      x = TApplicationException()
1920 
      x.read(self._iprot)
1921 
      self._iprot.readMessageEnd()
1922 
      raise x
1923 
    result = getOrderForCustomer_result()
1924 
    result.read(self._iprot)
1925 
    self._iprot.readMessageEnd()
3431 rajveer 1926 
    if result.success is not None:
1528 ankur.sing 1927 
      return result.success
3431 rajveer 1928 
    if result.ex is not None:
1528 ankur.sing 1929 
      raise result.ex
1930 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1931 
 
4444 rajveer 1932 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1933 
    """
1934 
    Parameters:
4394 rajveer 1935 
     - type
4444 rajveer 1936 
     - warehouseId
4394 rajveer 1937 
     - status
1938 
     - timestamp
3064 chandransh 1939 
    """
4444 rajveer 1940 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1941 
    return self.recv_getAlerts()
1942 
 
4444 rajveer 1943 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1944 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1945 
    args = getAlerts_args()
4394 rajveer 1946 
    args.type = type
4444 rajveer 1947 
    args.warehouseId = warehouseId
4394 rajveer 1948 
    args.status = status
1949 
    args.timestamp = timestamp
3064 chandransh 1950 
    args.write(self._oprot)
1951 
    self._oprot.writeMessageEnd()
1952 
    self._oprot.trans.flush()
1953 
 
1954 
  def recv_getAlerts(self, ):
1955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1956 
    if mtype == TMessageType.EXCEPTION:
1957 
      x = TApplicationException()
1958 
      x.read(self._iprot)
1959 
      self._iprot.readMessageEnd()
1960 
      raise x
1961 
    result = getAlerts_result()
1962 
    result.read(self._iprot)
1963 
    self._iprot.readMessageEnd()
3431 rajveer 1964 
    if result.success is not None:
3064 chandransh 1965 
      return result.success
1966 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1967 
 
4444 rajveer 1968 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1969 
    """
1970 
    Parameters:
1971 
     - type
4444 rajveer 1972 
     - warehouseId
4394 rajveer 1973 
     - description
3064 chandransh 1974 
    """
4444 rajveer 1975 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1976 
    self.recv_addAlert()
3064 chandransh 1977 
 
4444 rajveer 1978 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1979 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1980 
    args = addAlert_args()
3064 chandransh 1981 
    args.type = type
4444 rajveer 1982 
    args.warehouseId = warehouseId
4394 rajveer 1983 
    args.description = description
3064 chandransh 1984 
    args.write(self._oprot)
1985 
    self._oprot.writeMessageEnd()
1986 
    self._oprot.trans.flush()
1987 
 
4394 rajveer 1988 
  def recv_addAlert(self, ):
3064 chandransh 1989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1990 
    if mtype == TMessageType.EXCEPTION:
1991 
      x = TApplicationException()
1992 
      x.read(self._iprot)
1993 
      self._iprot.readMessageEnd()
1994 
      raise x
4394 rajveer 1995 
    result = addAlert_result()
3064 chandransh 1996 
    result.read(self._iprot)
1997 
    self._iprot.readMessageEnd()
1998 
    return
1999 
 
4444 rajveer 2000 
  def markAlertsAsSeen(self, warehouseId):
2001 
    """
2002 
    Parameters:
2003 
     - warehouseId
2004 
    """
2005 
    self.send_markAlertsAsSeen(warehouseId)
2006 
    self.recv_markAlertsAsSeen()
2007 
 
2008 
  def send_markAlertsAsSeen(self, warehouseId):
2009 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2010 
    args = markAlertsAsSeen_args()
2011 
    args.warehouseId = warehouseId
2012 
    args.write(self._oprot)
2013 
    self._oprot.writeMessageEnd()
2014 
    self._oprot.trans.flush()
2015 
 
2016 
  def recv_markAlertsAsSeen(self, ):
2017 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2018 
    if mtype == TMessageType.EXCEPTION:
2019 
      x = TApplicationException()
2020 
      x.read(self._iprot)
2021 
      self._iprot.readMessageEnd()
2022 
      raise x
2023 
    result = markAlertsAsSeen_result()
2024 
    result.read(self._iprot)
2025 
    self._iprot.readMessageEnd()
2026 
    return
2027 
 
3064 chandransh 2028 
  def getValidOrderCount(self, ):
2029 
    """
2030 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2031 
    """
2032 
    self.send_getValidOrderCount()
2033 
    return self.recv_getValidOrderCount()
2034 
 
2035 
  def send_getValidOrderCount(self, ):
2036 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2037 
    args = getValidOrderCount_args()
2038 
    args.write(self._oprot)
2039 
    self._oprot.writeMessageEnd()
2040 
    self._oprot.trans.flush()
2041 
 
2042 
  def recv_getValidOrderCount(self, ):
2043 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2044 
    if mtype == TMessageType.EXCEPTION:
2045 
      x = TApplicationException()
2046 
      x.read(self._iprot)
2047 
      self._iprot.readMessageEnd()
2048 
      raise x
2049 
    result = getValidOrderCount_result()
2050 
    result.read(self._iprot)
2051 
    self._iprot.readMessageEnd()
3431 rajveer 2052 
    if result.success is not None:
3064 chandransh 2053 
      return result.success
2054 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2055 
 
2056 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2057 
    """
2058 
    Returns the number of distinct customers who have done successful transactions
2059 
    """
2060 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2061 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2062 
 
2063 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2064 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2065 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2066 
    args.write(self._oprot)
2067 
    self._oprot.writeMessageEnd()
2068 
    self._oprot.trans.flush()
2069 
 
2070 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2071 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2072 
    if mtype == TMessageType.EXCEPTION:
2073 
      x = TApplicationException()
2074 
      x.read(self._iprot)
2075 
      self._iprot.readMessageEnd()
2076 
      raise x
2077 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2078 
    result.read(self._iprot)
2079 
    self._iprot.readMessageEnd()
3431 rajveer 2080 
    if result.success is not None:
3064 chandransh 2081 
      return result.success
2082 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2083 
 
2084 
  def getValidOrdersAmountRange(self, ):
2085 
    """
2086 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2087 
    List contains two values, first minimum amount and second maximum amount.
2088 
    """
2089 
    self.send_getValidOrdersAmountRange()
2090 
    return self.recv_getValidOrdersAmountRange()
2091 
 
2092 
  def send_getValidOrdersAmountRange(self, ):
2093 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2094 
    args = getValidOrdersAmountRange_args()
2095 
    args.write(self._oprot)
2096 
    self._oprot.writeMessageEnd()
2097 
    self._oprot.trans.flush()
2098 
 
2099 
  def recv_getValidOrdersAmountRange(self, ):
2100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2101 
    if mtype == TMessageType.EXCEPTION:
2102 
      x = TApplicationException()
2103 
      x.read(self._iprot)
2104 
      self._iprot.readMessageEnd()
2105 
      raise x
2106 
    result = getValidOrdersAmountRange_result()
2107 
    result.read(self._iprot)
2108 
    self._iprot.readMessageEnd()
3431 rajveer 2109 
    if result.success is not None:
3064 chandransh 2110 
      return result.success
2111 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2112 
 
2113 
  def getValidOrders(self, limit):
2114 
    """
2115 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2116 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2117 
 
3064 chandransh 2118 
    Parameters:
2119 
     - limit
2120 
    """
2121 
    self.send_getValidOrders(limit)
2122 
    return self.recv_getValidOrders()
2123 
 
2124 
  def send_getValidOrders(self, limit):
2125 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2126 
    args = getValidOrders_args()
2127 
    args.limit = limit
2128 
    args.write(self._oprot)
2129 
    self._oprot.writeMessageEnd()
2130 
    self._oprot.trans.flush()
2131 
 
2132 
  def recv_getValidOrders(self, ):
2133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2134 
    if mtype == TMessageType.EXCEPTION:
2135 
      x = TApplicationException()
2136 
      x.read(self._iprot)
2137 
      self._iprot.readMessageEnd()
2138 
      raise x
2139 
    result = getValidOrders_result()
2140 
    result.read(self._iprot)
2141 
    self._iprot.readMessageEnd()
3431 rajveer 2142 
    if result.success is not None:
3064 chandransh 2143 
      return result.success
2144 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2145 
 
1220 chandransh 2146 
  def batchOrders(self, warehouseId):
2147 
    """
2148 
    Create a batch of all the pending orders for the given warehouse.
2149 
    The returned list is orderd by created_timestamp.
2150 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2151 
 
1220 chandransh 2152 
    Parameters:
2153 
     - warehouseId
2154 
    """
2155 
    self.send_batchOrders(warehouseId)
2156 
    return self.recv_batchOrders()
2157 
 
2158 
  def send_batchOrders(self, warehouseId):
2159 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2160 
    args = batchOrders_args()
2161 
    args.warehouseId = warehouseId
2162 
    args.write(self._oprot)
2163 
    self._oprot.writeMessageEnd()
2164 
    self._oprot.trans.flush()
2165 
 
2166 
  def recv_batchOrders(self, ):
2167 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2168 
    if mtype == TMessageType.EXCEPTION:
2169 
      x = TApplicationException()
2170 
      x.read(self._iprot)
2171 
      self._iprot.readMessageEnd()
2172 
      raise x
2173 
    result = batchOrders_result()
2174 
    result.read(self._iprot)
2175 
    self._iprot.readMessageEnd()
3431 rajveer 2176 
    if result.success is not None:
1220 chandransh 2177 
      return result.success
3431 rajveer 2178 
    if result.ex is not None:
1220 chandransh 2179 
      raise result.ex
2180 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2181 
 
1208 chandransh 2182 
  def markOrderAsOutOfStock(self, orderId):
2183 
    """
2184 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2185 
 
1208 chandransh 2186 
    Parameters:
2187 
     - orderId
2188 
    """
2189 
    self.send_markOrderAsOutOfStock(orderId)
2190 
    return self.recv_markOrderAsOutOfStock()
2191 
 
2192 
  def send_markOrderAsOutOfStock(self, orderId):
2193 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2194 
    args = markOrderAsOutOfStock_args()
2195 
    args.orderId = orderId
2196 
    args.write(self._oprot)
2197 
    self._oprot.writeMessageEnd()
2198 
    self._oprot.trans.flush()
2199 
 
2200 
  def recv_markOrderAsOutOfStock(self, ):
2201 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2202 
    if mtype == TMessageType.EXCEPTION:
2203 
      x = TApplicationException()
2204 
      x.read(self._iprot)
2205 
      self._iprot.readMessageEnd()
2206 
      raise x
2207 
    result = markOrderAsOutOfStock_result()
2208 
    result.read(self._iprot)
2209 
    self._iprot.readMessageEnd()
3431 rajveer 2210 
    if result.success is not None:
1208 chandransh 2211 
      return result.success
3431 rajveer 2212 
    if result.ex is not None:
1208 chandransh 2213 
      raise result.ex
2214 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2215 
 
3064 chandransh 2216 
  def verifyOrder(self, orderId):
759 chandransh 2217 
    """
3064 chandransh 2218 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2219 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2220 
    used for all other orders as well.
2221 
    Throws an exception if no such order exists.
3431 rajveer 2222 
 
759 chandransh 2223 
    Parameters:
3064 chandransh 2224 
     - orderId
759 chandransh 2225 
    """
3064 chandransh 2226 
    self.send_verifyOrder(orderId)
2227 
    return self.recv_verifyOrder()
759 chandransh 2228 
 
3064 chandransh 2229 
  def send_verifyOrder(self, orderId):
2230 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2231 
    args = verifyOrder_args()
2232 
    args.orderId = orderId
759 chandransh 2233 
    args.write(self._oprot)
2234 
    self._oprot.writeMessageEnd()
2235 
    self._oprot.trans.flush()
2236 
 
3064 chandransh 2237 
  def recv_verifyOrder(self, ):
759 chandransh 2238 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2239 
    if mtype == TMessageType.EXCEPTION:
2240 
      x = TApplicationException()
2241 
      x.read(self._iprot)
2242 
      self._iprot.readMessageEnd()
2243 
      raise x
3064 chandransh 2244 
    result = verifyOrder_result()
759 chandransh 2245 
    result.read(self._iprot)
2246 
    self._iprot.readMessageEnd()
3431 rajveer 2247 
    if result.success is not None:
759 chandransh 2248 
      return result.success
3431 rajveer 2249 
    if result.ex is not None:
759 chandransh 2250 
      raise result.ex
3064 chandransh 2251 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2252 
 
3064 chandransh 2253 
  def acceptOrder(self, orderId):
1113 chandransh 2254 
    """
3064 chandransh 2255 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2256 
    given order is not a COD order, it also captures the payment if the same has
2257 
    not been captured.
2258 
    Throws an exception if no such order exists.
3431 rajveer 2259 
 
1113 chandransh 2260 
    Parameters:
3064 chandransh 2261 
     - orderId
1113 chandransh 2262 
    """
3064 chandransh 2263 
    self.send_acceptOrder(orderId)
2264 
    return self.recv_acceptOrder()
1113 chandransh 2265 
 
3064 chandransh 2266 
  def send_acceptOrder(self, orderId):
2267 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2268 
    args = acceptOrder_args()
2269 
    args.orderId = orderId
1113 chandransh 2270 
    args.write(self._oprot)
2271 
    self._oprot.writeMessageEnd()
2272 
    self._oprot.trans.flush()
2273 
 
3064 chandransh 2274 
  def recv_acceptOrder(self, ):
1113 chandransh 2275 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2276 
    if mtype == TMessageType.EXCEPTION:
2277 
      x = TApplicationException()
2278 
      x.read(self._iprot)
2279 
      self._iprot.readMessageEnd()
2280 
      raise x
3064 chandransh 2281 
    result = acceptOrder_result()
1113 chandransh 2282 
    result.read(self._iprot)
2283 
    self._iprot.readMessageEnd()
3431 rajveer 2284 
    if result.success is not None:
1113 chandransh 2285 
      return result.success
3431 rajveer 2286 
    if result.ex is not None:
1113 chandransh 2287 
      raise result.ex
3064 chandransh 2288 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2289 
 
5110 mandeep.dh 2290 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2291 
    """
3064 chandransh 2292 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2293 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2294 
    the IMEI no. if a -1 is supplied.
2295 
    Also, it generates an invoice number for the order, marks the order as
2296 
    BILLED and sets the billing timestamp.
2297 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2298 
 
1135 chandransh 2299 
    Parameters:
3064 chandransh 2300 
     - orderId
2301 
     - invoice_number
4658 mandeep.dh 2302 
     - serialNumber
4283 anupam.sin 2303 
     - itemNumber
3064 chandransh 2304 
     - billed_by
4264 rajveer 2305 
     - jacketNumber
4283 anupam.sin 2306 
     - billingType
5110 mandeep.dh 2307 
     - fulfilmentWarehouseId
4763 rajveer 2308 
     - authorize
1135 chandransh 2309 
    """
5110 mandeep.dh 2310 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2311 
    return self.recv_addBillingDetails()
1135 chandransh 2312 
 
5110 mandeep.dh 2313 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2314 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2315 
    args = addBillingDetails_args()
2316 
    args.orderId = orderId
2317 
    args.invoice_number = invoice_number
4658 mandeep.dh 2318 
    args.serialNumber = serialNumber
4283 anupam.sin 2319 
    args.itemNumber = itemNumber
3064 chandransh 2320 
    args.billed_by = billed_by
4264 rajveer 2321 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2322 
    args.billingType = billingType
5110 mandeep.dh 2323 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2324 
    args.authorize = authorize
1135 chandransh 2325 
    args.write(self._oprot)
2326 
    self._oprot.writeMessageEnd()
2327 
    self._oprot.trans.flush()
2328 
 
3064 chandransh 2329 
  def recv_addBillingDetails(self, ):
1135 chandransh 2330 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2331 
    if mtype == TMessageType.EXCEPTION:
2332 
      x = TApplicationException()
2333 
      x.read(self._iprot)
2334 
      self._iprot.readMessageEnd()
2335 
      raise x
3064 chandransh 2336 
    result = addBillingDetails_result()
1135 chandransh 2337 
    result.read(self._iprot)
2338 
    self._iprot.readMessageEnd()
3431 rajveer 2339 
    if result.success is not None:
3064 chandransh 2340 
      return result.success
3431 rajveer 2341 
    if result.ex is not None:
1135 chandransh 2342 
      raise result.ex
3064 chandransh 2343 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2344 
 
4763 rajveer 2345 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2346 
    """
2347 
    Add the invoice number to the order.
2348 
 
2349 
    Parameters:
2350 
     - orderId
2351 
     - invoiceNumber
4763 rajveer 2352 
     - color
4579 rajveer 2353 
    """
4763 rajveer 2354 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2355 
    self.recv_addInvoiceNumber()
2356 
 
4763 rajveer 2357 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2358 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2359 
    args = addInvoiceNumber_args()
2360 
    args.orderId = orderId
2361 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2362 
    args.color = color
4579 rajveer 2363 
    args.write(self._oprot)
2364 
    self._oprot.writeMessageEnd()
2365 
    self._oprot.trans.flush()
2366 
 
2367 
  def recv_addInvoiceNumber(self, ):
2368 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2369 
    if mtype == TMessageType.EXCEPTION:
2370 
      x = TApplicationException()
2371 
      x.read(self._iprot)
2372 
      self._iprot.readMessageEnd()
2373 
      raise x
2374 
    result = addInvoiceNumber_result()
2375 
    result.read(self._iprot)
2376 
    self._iprot.readMessageEnd()
2377 
    if result.ex is not None:
2378 
      raise result.ex
2379 
    return
2380 
 
4910 phani.kuma 2381 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2382 
    """
3064 chandransh 2383 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2384 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2385 
 
1408 ankur.sing 2386 
    Parameters:
3064 chandransh 2387 
     - warehouseId
1408 ankur.sing 2388 
     - providerId
3064 chandransh 2389 
     - cod
4910 phani.kuma 2390 
     - orderIds
1408 ankur.sing 2391 
    """
4910 phani.kuma 2392 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2393 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2394 
 
4910 phani.kuma 2395 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2396 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2397 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2398 
    args.warehouseId = warehouseId
1408 ankur.sing 2399 
    args.providerId = providerId
3064 chandransh 2400 
    args.cod = cod
4910 phani.kuma 2401 
    args.orderIds = orderIds
1408 ankur.sing 2402 
    args.write(self._oprot)
2403 
    self._oprot.writeMessageEnd()
2404 
    self._oprot.trans.flush()
2405 
 
4910 phani.kuma 2406 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2408 
    if mtype == TMessageType.EXCEPTION:
2409 
      x = TApplicationException()
2410 
      x.read(self._iprot)
2411 
      self._iprot.readMessageEnd()
2412 
      raise x
4910 phani.kuma 2413 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2414 
    result.read(self._iprot)
2415 
    self._iprot.readMessageEnd()
3431 rajveer 2416 
    if result.success is not None:
1408 ankur.sing 2417 
      return result.success
3431 rajveer 2418 
    if result.ex is not None:
3064 chandransh 2419 
      raise result.ex
4910 phani.kuma 2420 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2421 
 
4910 phani.kuma 2422 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2423 
    """
4910 phani.kuma 2424 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2425 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2426 
 
2427 
    Parameters:
2428 
     - providerId
4910 phani.kuma 2429 
     - pickupDetails
4410 rajveer 2430 
    """
4910 phani.kuma 2431 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2432 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2433 
 
4910 phani.kuma 2434 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2435 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2436 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2437 
    args.providerId = providerId
4910 phani.kuma 2438 
    args.pickupDetails = pickupDetails
4410 rajveer 2439 
    args.write(self._oprot)
2440 
    self._oprot.writeMessageEnd()
2441 
    self._oprot.trans.flush()
2442 
 
4910 phani.kuma 2443 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2445 
    if mtype == TMessageType.EXCEPTION:
2446 
      x = TApplicationException()
2447 
      x.read(self._iprot)
2448 
      self._iprot.readMessageEnd()
2449 
      raise x
4910 phani.kuma 2450 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2451 
    result.read(self._iprot)
2452 
    self._iprot.readMessageEnd()
2453 
    if result.ex is not None:
2454 
      raise result.ex
4910 phani.kuma 2455 
    return
4410 rajveer 2456 
 
4910 phani.kuma 2457 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2458 
    """
3064 chandransh 2459 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2460 
 
94 ashish 2461 
    Parameters:
3064 chandransh 2462 
     - providerId
304 ashish 2463 
    """
4910 phani.kuma 2464 
    self.send_getOrdersNotPickedUp(providerId)
2465 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2466 
 
4910 phani.kuma 2467 
  def send_getOrdersNotPickedUp(self, providerId):
2468 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2469 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2470 
    args.providerId = providerId
304 ashish 2471 
    args.write(self._oprot)
2472 
    self._oprot.writeMessageEnd()
2473 
    self._oprot.trans.flush()
2474 
 
4910 phani.kuma 2475 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2476 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2477 
    if mtype == TMessageType.EXCEPTION:
2478 
      x = TApplicationException()
2479 
      x.read(self._iprot)
2480 
      self._iprot.readMessageEnd()
2481 
      raise x
4910 phani.kuma 2482 
    result = getOrdersNotPickedUp_result()
304 ashish 2483 
    result.read(self._iprot)
2484 
    self._iprot.readMessageEnd()
3431 rajveer 2485 
    if result.success is not None:
304 ashish 2486 
      return result.success
4910 phani.kuma 2487 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2488 
 
3064 chandransh 2489 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2490 
    """
3064 chandransh 2491 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2492 
    the name of the receiver.
2493 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2494 
 
304 ashish 2495 
    Parameters:
3064 chandransh 2496 
     - providerId
2497 
     - deliveredOrders
304 ashish 2498 
    """
3064 chandransh 2499 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2500 
    self.recv_markOrdersAsDelivered()
304 ashish 2501 
 
3064 chandransh 2502 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2503 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2504 
    args = markOrdersAsDelivered_args()
2505 
    args.providerId = providerId
2506 
    args.deliveredOrders = deliveredOrders
304 ashish 2507 
    args.write(self._oprot)
2508 
    self._oprot.writeMessageEnd()
2509 
    self._oprot.trans.flush()
2510 
 
3064 chandransh 2511 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2512 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2513 
    if mtype == TMessageType.EXCEPTION:
2514 
      x = TApplicationException()
2515 
      x.read(self._iprot)
2516 
      self._iprot.readMessageEnd()
2517 
      raise x
3064 chandransh 2518 
    result = markOrdersAsDelivered_result()
304 ashish 2519 
    result.read(self._iprot)
2520 
    self._iprot.readMessageEnd()
3431 rajveer 2521 
    if result.ex is not None:
3064 chandransh 2522 
      raise result.ex
304 ashish 2523 
    return
2524 
 
4910 phani.kuma 2525 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2526 
    """
4910 phani.kuma 2527 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2528 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2529 
 
3064 chandransh 2530 
    Parameters:
2531 
     - providerId
2532 
     - returnedOrders
1596 ankur.sing 2533 
    """
4910 phani.kuma 2534 
    self.send_markAsRTOrders(providerId, returnedOrders)
2535 
    self.recv_markAsRTOrders()
304 ashish 2536 
 
4910 phani.kuma 2537 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2538 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2539 
    args = markAsRTOrders_args()
3064 chandransh 2540 
    args.providerId = providerId
2541 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2542 
    args.write(self._oprot)
2543 
    self._oprot.writeMessageEnd()
2544 
    self._oprot.trans.flush()
2545 
 
4910 phani.kuma 2546 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2547 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2548 
    if mtype == TMessageType.EXCEPTION:
2549 
      x = TApplicationException()
2550 
      x.read(self._iprot)
2551 
      self._iprot.readMessageEnd()
2552 
      raise x
4910 phani.kuma 2553 
    result = markAsRTOrders_result()
1596 ankur.sing 2554 
    result.read(self._iprot)
2555 
    self._iprot.readMessageEnd()
3431 rajveer 2556 
    if result.ex is not None:
3064 chandransh 2557 
      raise result.ex
2558 
    return
1596 ankur.sing 2559 
 
4910 phani.kuma 2560 
  def getRTOrders(self, providerId):
2561 
    """
2562 
    Returns a list of orders that were returned by courier.
2563 
 
2564 
    Parameters:
2565 
     - providerId
2566 
    """
2567 
    self.send_getRTOrders(providerId)
2568 
    return self.recv_getRTOrders()
2569 
 
2570 
  def send_getRTOrders(self, providerId):
2571 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2572 
    args = getRTOrders_args()
2573 
    args.providerId = providerId
2574 
    args.write(self._oprot)
2575 
    self._oprot.writeMessageEnd()
2576 
    self._oprot.trans.flush()
2577 
 
2578 
  def recv_getRTOrders(self, ):
2579 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2580 
    if mtype == TMessageType.EXCEPTION:
2581 
      x = TApplicationException()
2582 
      x.read(self._iprot)
2583 
      self._iprot.readMessageEnd()
2584 
      raise x
2585 
    result = getRTOrders_result()
2586 
    result.read(self._iprot)
2587 
    self._iprot.readMessageEnd()
2588 
    if result.success is not None:
2589 
      return result.success
2590 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2591 
 
3064 chandransh 2592 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2593 
    """
3064 chandransh 2594 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2595 
 
3064 chandransh 2596 
    Parameters:
2597 
     - providerId
2598 
     - undeliveredOrders
1627 ankur.sing 2599 
    """
3064 chandransh 2600 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2601 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2602 
 
3064 chandransh 2603 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2604 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2605 
    args = updateNonDeliveryReason_args()
2606 
    args.providerId = providerId
2607 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2608 
    args.write(self._oprot)
2609 
    self._oprot.writeMessageEnd()
2610 
    self._oprot.trans.flush()
2611 
 
3064 chandransh 2612 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2613 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2614 
    if mtype == TMessageType.EXCEPTION:
2615 
      x = TApplicationException()
2616 
      x.read(self._iprot)
2617 
      self._iprot.readMessageEnd()
2618 
      raise x
3064 chandransh 2619 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2620 
    result.read(self._iprot)
2621 
    self._iprot.readMessageEnd()
4910 phani.kuma 2622 
    if result.ex is not None:
2623 
      raise result.ex
2624 
    return
2625 
 
2626 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2627 
    """
2628 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2629 
 
2630 
    Parameters:
2631 
     - providerId
2632 
    """
2633 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2634 
    return self.recv_getNonDeliveredOrdersbyCourier()
2635 
 
2636 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2637 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2638 
    args = getNonDeliveredOrdersbyCourier_args()
2639 
    args.providerId = providerId
2640 
    args.write(self._oprot)
2641 
    self._oprot.writeMessageEnd()
2642 
    self._oprot.trans.flush()
2643 
 
2644 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2645 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2646 
    if mtype == TMessageType.EXCEPTION:
2647 
      x = TApplicationException()
2648 
      x.read(self._iprot)
2649 
      self._iprot.readMessageEnd()
2650 
      raise x
2651 
    result = getNonDeliveredOrdersbyCourier_result()
2652 
    result.read(self._iprot)
2653 
    self._iprot.readMessageEnd()
4581 phani.kuma 2654 
    if result.success is not None:
2655 
      return result.success
4910 phani.kuma 2656 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2657 
 
2658 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2659 
    """
2660 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2661 
 
2662 
    Parameters:
2663 
     - providerId
2664 
     - local_connected_orders
2665 
    """
2666 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2667 
    self.recv_markOrdersAsLocalConnected()
2668 
 
2669 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2670 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2671 
    args = markOrdersAsLocalConnected_args()
2672 
    args.providerId = providerId
2673 
    args.local_connected_orders = local_connected_orders
2674 
    args.write(self._oprot)
2675 
    self._oprot.writeMessageEnd()
2676 
    self._oprot.trans.flush()
2677 
 
2678 
  def recv_markOrdersAsLocalConnected(self, ):
2679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2680 
    if mtype == TMessageType.EXCEPTION:
2681 
      x = TApplicationException()
2682 
      x.read(self._iprot)
2683 
      self._iprot.readMessageEnd()
2684 
      raise x
2685 
    result = markOrdersAsLocalConnected_result()
2686 
    result.read(self._iprot)
2687 
    self._iprot.readMessageEnd()
3431 rajveer 2688 
    if result.ex is not None:
3064 chandransh 2689 
      raise result.ex
4910 phani.kuma 2690 
    return
1627 ankur.sing 2691 
 
4910 phani.kuma 2692 
  def getOrdersNotLocalConnected(self, providerId):
2693 
    """
2694 
    Returns a list of orders that were picked up or shipped but pending local connection.
2695 
 
2696 
    Parameters:
2697 
     - providerId
2698 
    """
2699 
    self.send_getOrdersNotLocalConnected(providerId)
2700 
    return self.recv_getOrdersNotLocalConnected()
2701 
 
2702 
  def send_getOrdersNotLocalConnected(self, providerId):
2703 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2704 
    args = getOrdersNotLocalConnected_args()
2705 
    args.providerId = providerId
2706 
    args.write(self._oprot)
2707 
    self._oprot.writeMessageEnd()
2708 
    self._oprot.trans.flush()
2709 
 
2710 
  def recv_getOrdersNotLocalConnected(self, ):
2711 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2712 
    if mtype == TMessageType.EXCEPTION:
2713 
      x = TApplicationException()
2714 
      x.read(self._iprot)
2715 
      self._iprot.readMessageEnd()
2716 
      raise x
2717 
    result = getOrdersNotLocalConnected_result()
2718 
    result.read(self._iprot)
2719 
    self._iprot.readMessageEnd()
2720 
    if result.success is not None:
2721 
      return result.success
2722 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2723 
 
2724 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2725 
    """
2726 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2727 
 
2728 
    Parameters:
2729 
     - providerId
2730 
     - destination_city_reached_orders
2731 
    """
2732 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2733 
    self.recv_markOrdersAsDestinationCityReached()
2734 
 
2735 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2736 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2737 
    args = markOrdersAsDestinationCityReached_args()
2738 
    args.providerId = providerId
2739 
    args.destination_city_reached_orders = destination_city_reached_orders
2740 
    args.write(self._oprot)
2741 
    self._oprot.writeMessageEnd()
2742 
    self._oprot.trans.flush()
2743 
 
2744 
  def recv_markOrdersAsDestinationCityReached(self, ):
2745 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2746 
    if mtype == TMessageType.EXCEPTION:
2747 
      x = TApplicationException()
2748 
      x.read(self._iprot)
2749 
      self._iprot.readMessageEnd()
2750 
      raise x
2751 
    result = markOrdersAsDestinationCityReached_result()
2752 
    result.read(self._iprot)
2753 
    self._iprot.readMessageEnd()
2754 
    if result.ex is not None:
2755 
      raise result.ex
2756 
    return
2757 
 
2758 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2759 
    """
2760 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
2761 
 
2762 
    Parameters:
2763 
     - providerId
2764 
     - first_atdl_orders
2765 
    """
2766 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
2767 
    self.recv_markOrdersAsFirstDeliveryAttempted()
2768 
 
2769 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2770 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
2771 
    args = markOrdersAsFirstDeliveryAttempted_args()
2772 
    args.providerId = providerId
2773 
    args.first_atdl_orders = first_atdl_orders
2774 
    args.write(self._oprot)
2775 
    self._oprot.writeMessageEnd()
2776 
    self._oprot.trans.flush()
2777 
 
2778 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
2779 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2780 
    if mtype == TMessageType.EXCEPTION:
2781 
      x = TApplicationException()
2782 
      x.read(self._iprot)
2783 
      self._iprot.readMessageEnd()
2784 
      raise x
2785 
    result = markOrdersAsFirstDeliveryAttempted_result()
2786 
    result.read(self._iprot)
2787 
    self._iprot.readMessageEnd()
2788 
    if result.ex is not None:
2789 
      raise result.ex
2790 
    return
2791 
 
3064 chandransh 2792 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2793 
    """
3064 chandransh 2794 
    Returns the list of orders whose delivery time has passed but have not been
2795 
    delivered yet for the given provider and warehouse. To get a complete list of
2796 
    undelivered orders, pass them as -1.
2797 
    Returns an empty list if no such orders exist.
3431 rajveer 2798 
 
1886 ankur.sing 2799 
    Parameters:
3064 chandransh 2800 
     - providerId
2801 
     - warehouseId
1886 ankur.sing 2802 
    """
3064 chandransh 2803 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2804 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2805 
 
3064 chandransh 2806 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2807 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2808 
    args = getUndeliveredOrders_args()
2809 
    args.providerId = providerId
2810 
    args.warehouseId = warehouseId
1886 ankur.sing 2811 
    args.write(self._oprot)
2812 
    self._oprot.writeMessageEnd()
2813 
    self._oprot.trans.flush()
2814 
 
3064 chandransh 2815 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2816 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2817 
    if mtype == TMessageType.EXCEPTION:
2818 
      x = TApplicationException()
2819 
      x.read(self._iprot)
2820 
      self._iprot.readMessageEnd()
2821 
      raise x
3064 chandransh 2822 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2823 
    result.read(self._iprot)
2824 
    self._iprot.readMessageEnd()
3431 rajveer 2825 
    if result.success is not None:
1886 ankur.sing 2826 
      return result.success
3064 chandransh 2827 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2828 
 
4783 phani.kuma 2829 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2830 
    """
2831 
    Returns the list of orders whose expected delivery date has passed but have not been
2832 
    delivered yet.
2833 
    Returns an empty list if no such orders exist.
2834 
    """
2835 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2836 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2837 
 
2838 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2839 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2840 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2841 
    args.write(self._oprot)
2842 
    self._oprot.writeMessageEnd()
2843 
    self._oprot.trans.flush()
2844 
 
2845 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2846 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2847 
    if mtype == TMessageType.EXCEPTION:
2848 
      x = TApplicationException()
2849 
      x.read(self._iprot)
2850 
      self._iprot.readMessageEnd()
2851 
      raise x
2852 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2853 
    result.read(self._iprot)
2854 
    self._iprot.readMessageEnd()
2855 
    if result.success is not None:
2856 
      return result.success
2857 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2858 
 
2536 chandransh 2859 
  def toggleDOAFlag(self, orderId):
2860 
    """
2861 
    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.
2862 
    Returns the final flag status.
2863 
    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 2864 
 
2536 chandransh 2865 
    Parameters:
2866 
     - orderId
2867 
    """
2868 
    self.send_toggleDOAFlag(orderId)
2869 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2870 
 
2536 chandransh 2871 
  def send_toggleDOAFlag(self, orderId):
2872 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2873 
    args = toggleDOAFlag_args()
2874 
    args.orderId = orderId
2875 
    args.write(self._oprot)
2876 
    self._oprot.writeMessageEnd()
2877 
    self._oprot.trans.flush()
2878 
 
2879 
  def recv_toggleDOAFlag(self, ):
2880 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2881 
    if mtype == TMessageType.EXCEPTION:
2882 
      x = TApplicationException()
2883 
      x.read(self._iprot)
2884 
      self._iprot.readMessageEnd()
2885 
      raise x
2886 
    result = toggleDOAFlag_result()
2887 
    result.read(self._iprot)
2888 
    self._iprot.readMessageEnd()
3431 rajveer 2889 
    if result.success is not None:
2536 chandransh 2890 
      return result.success
3431 rajveer 2891 
    if result.ex is not None:
2536 chandransh 2892 
      raise result.ex
2893 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2894 
 
4712 rajveer 2895 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2896 
    """
2897 
    Parameters:
2898 
     - orderId
2899 
     - deliveryTimestamp
2900 
     - receiver
2901 
    """
2902 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2903 
    self.recv_markOrderAsDelivered()
2904 
 
2905 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2906 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2907 
    args = markOrderAsDelivered_args()
2908 
    args.orderId = orderId
2909 
    args.deliveryTimestamp = deliveryTimestamp
2910 
    args.receiver = receiver
2911 
    args.write(self._oprot)
2912 
    self._oprot.writeMessageEnd()
2913 
    self._oprot.trans.flush()
2914 
 
2915 
  def recv_markOrderAsDelivered(self, ):
2916 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2917 
    if mtype == TMessageType.EXCEPTION:
2918 
      x = TApplicationException()
2919 
      x.read(self._iprot)
2920 
      self._iprot.readMessageEnd()
2921 
      raise x
2922 
    result = markOrderAsDelivered_result()
2923 
    result.read(self._iprot)
2924 
    self._iprot.readMessageEnd()
2925 
    if result.ex is not None:
2926 
      raise result.ex
2927 
    return
2928 
 
4454 rajveer 2929 
  def markOrderDoaRequestReceived(self, orderId):
2930 
    """
2931 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2932 
 
2933 
    Parameters:
2934 
     - orderId
2935 
    """
2936 
    self.send_markOrderDoaRequestReceived(orderId)
2937 
    return self.recv_markOrderDoaRequestReceived()
2938 
 
2939 
  def send_markOrderDoaRequestReceived(self, orderId):
2940 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2941 
    args = markOrderDoaRequestReceived_args()
2942 
    args.orderId = orderId
2943 
    args.write(self._oprot)
2944 
    self._oprot.writeMessageEnd()
2945 
    self._oprot.trans.flush()
2946 
 
2947 
  def recv_markOrderDoaRequestReceived(self, ):
2948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2949 
    if mtype == TMessageType.EXCEPTION:
2950 
      x = TApplicationException()
2951 
      x.read(self._iprot)
2952 
      self._iprot.readMessageEnd()
2953 
      raise x
2954 
    result = markOrderDoaRequestReceived_result()
2955 
    result.read(self._iprot)
2956 
    self._iprot.readMessageEnd()
2957 
    if result.success is not None:
2958 
      return result.success
2959 
    if result.ex is not None:
2960 
      raise result.ex
2961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2962 
 
2963 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2964 
    """
2965 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2966 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2967 
 
2968 
    Parameters:
2969 
     - orderId
2970 
     - isAuthorized
2971 
    """
2972 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2973 
    return self.recv_markOrderDoaRequestAuthorized()
2974 
 
2975 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2976 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2977 
    args = markOrderDoaRequestAuthorized_args()
2978 
    args.orderId = orderId
2979 
    args.isAuthorized = isAuthorized
2980 
    args.write(self._oprot)
2981 
    self._oprot.writeMessageEnd()
2982 
    self._oprot.trans.flush()
2983 
 
2984 
  def recv_markOrderDoaRequestAuthorized(self, ):
2985 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2986 
    if mtype == TMessageType.EXCEPTION:
2987 
      x = TApplicationException()
2988 
      x.read(self._iprot)
2989 
      self._iprot.readMessageEnd()
2990 
      raise x
2991 
    result = markOrderDoaRequestAuthorized_result()
2992 
    result.read(self._iprot)
2993 
    self._iprot.readMessageEnd()
2994 
    if result.success is not None:
2995 
      return result.success
2996 
    if result.ex is not None:
2997 
      raise result.ex
2998 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2999 
 
4488 rajveer 3000 
  def markOrderReturnRequestReceived(self, orderId):
3001 
    """
3002 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3003 
 
3004 
    Parameters:
3005 
     - orderId
3006 
    """
3007 
    self.send_markOrderReturnRequestReceived(orderId)
3008 
    return self.recv_markOrderReturnRequestReceived()
3009 
 
3010 
  def send_markOrderReturnRequestReceived(self, orderId):
3011 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3012 
    args = markOrderReturnRequestReceived_args()
3013 
    args.orderId = orderId
3014 
    args.write(self._oprot)
3015 
    self._oprot.writeMessageEnd()
3016 
    self._oprot.trans.flush()
3017 
 
3018 
  def recv_markOrderReturnRequestReceived(self, ):
3019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3020 
    if mtype == TMessageType.EXCEPTION:
3021 
      x = TApplicationException()
3022 
      x.read(self._iprot)
3023 
      self._iprot.readMessageEnd()
3024 
      raise x
3025 
    result = markOrderReturnRequestReceived_result()
3026 
    result.read(self._iprot)
3027 
    self._iprot.readMessageEnd()
3028 
    if result.success is not None:
3029 
      return result.success
3030 
    if result.ex is not None:
3031 
      raise result.ex
3032 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3033 
 
3034 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3035 
    """
3036 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3037 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3038 
 
3039 
    Parameters:
3040 
     - orderId
3041 
     - isAuthorized
3042 
    """
3043 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3044 
    return self.recv_markOrderReturnRequestAuthorized()
3045 
 
3046 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3047 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3048 
    args = markOrderReturnRequestAuthorized_args()
3049 
    args.orderId = orderId
3050 
    args.isAuthorized = isAuthorized
3051 
    args.write(self._oprot)
3052 
    self._oprot.writeMessageEnd()
3053 
    self._oprot.trans.flush()
3054 
 
3055 
  def recv_markOrderReturnRequestAuthorized(self, ):
3056 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3057 
    if mtype == TMessageType.EXCEPTION:
3058 
      x = TApplicationException()
3059 
      x.read(self._iprot)
3060 
      self._iprot.readMessageEnd()
3061 
      raise x
3062 
    result = markOrderReturnRequestAuthorized_result()
3063 
    result.read(self._iprot)
3064 
    self._iprot.readMessageEnd()
3065 
    if result.success is not None:
3066 
      return result.success
3067 
    if result.ex is not None:
3068 
      raise result.ex
3069 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3070 
 
4579 rajveer 3071 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3072 
    """
3073 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3074 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3075 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3076 
    For any other status, it returns false.
3077 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3078 
 
2536 chandransh 3079 
    Parameters:
3080 
     - orderId
4579 rajveer 3081 
     - providerId
2536 chandransh 3082 
    """
4579 rajveer 3083 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3084 
    return self.recv_requestPickupNumber()
3085 
 
4579 rajveer 3086 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3087 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3088 
    args = requestPickupNumber_args()
3089 
    args.orderId = orderId
4579 rajveer 3090 
    args.providerId = providerId
2536 chandransh 3091 
    args.write(self._oprot)
3092 
    self._oprot.writeMessageEnd()
3093 
    self._oprot.trans.flush()
3094 
 
3095 
  def recv_requestPickupNumber(self, ):
3096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3097 
    if mtype == TMessageType.EXCEPTION:
3098 
      x = TApplicationException()
3099 
      x.read(self._iprot)
3100 
      self._iprot.readMessageEnd()
3101 
      raise x
3102 
    result = requestPickupNumber_result()
3103 
    result.read(self._iprot)
3104 
    self._iprot.readMessageEnd()
3431 rajveer 3105 
    if result.success is not None:
2536 chandransh 3106 
      return result.success
3431 rajveer 3107 
    if result.ex is not None:
2536 chandransh 3108 
      raise result.ex
3109 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3110 
 
4602 rajveer 3111 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3112 
    """
4452 rajveer 3113 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3114 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3115 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3116 
    	3. Returns true
2591 chandransh 3117 
    If the order is in any other status, it returns false.
2536 chandransh 3118 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3119 
 
2536 chandransh 3120 
    Parameters:
3121 
     - orderId
3122 
     - pickupNumber
4602 rajveer 3123 
     - providerId
2536 chandransh 3124 
    """
4602 rajveer 3125 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3126 
    return self.recv_authorizePickup()
3127 
 
4602 rajveer 3128 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3129 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3130 
    args = authorizePickup_args()
3131 
    args.orderId = orderId
3132 
    args.pickupNumber = pickupNumber
4602 rajveer 3133 
    args.providerId = providerId
2536 chandransh 3134 
    args.write(self._oprot)
3135 
    self._oprot.writeMessageEnd()
3136 
    self._oprot.trans.flush()
3137 
 
3138 
  def recv_authorizePickup(self, ):
3139 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3140 
    if mtype == TMessageType.EXCEPTION:
3141 
      x = TApplicationException()
3142 
      x.read(self._iprot)
3143 
      self._iprot.readMessageEnd()
3144 
      raise x
3145 
    result = authorizePickup_result()
3146 
    result.read(self._iprot)
3147 
    self._iprot.readMessageEnd()
3431 rajveer 3148 
    if result.success is not None:
2536 chandransh 3149 
      return result.success
3431 rajveer 3150 
    if result.ex is not None:
2536 chandransh 3151 
      raise result.ex
3152 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3153 
 
2764 chandransh 3154 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3155 
    """
3156 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3157 
 
2764 chandransh 3158 
    Parameters:
3159 
     - providerId
3160 
     - pickupDetails
3161 
    """
3162 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3163 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3164 
 
3165 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3166 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3167 
    args = markDoasAsPickedUp_args()
3168 
    args.providerId = providerId
3169 
    args.pickupDetails = pickupDetails
3170 
    args.write(self._oprot)
3171 
    self._oprot.writeMessageEnd()
3172 
    self._oprot.trans.flush()
3173 
 
3174 
  def recv_markDoasAsPickedUp(self, ):
3175 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3176 
    if mtype == TMessageType.EXCEPTION:
3177 
      x = TApplicationException()
3178 
      x.read(self._iprot)
3179 
      self._iprot.readMessageEnd()
3180 
      raise x
3181 
    result = markDoasAsPickedUp_result()
3182 
    result.read(self._iprot)
3183 
    self._iprot.readMessageEnd()
4910 phani.kuma 3184 
    return
3185 
 
3186 
  def getDoasNotPickedUp(self, providerId):
3187 
    """
3188 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3189 
 
3190 
    Parameters:
3191 
     - providerId
3192 
    """
3193 
    self.send_getDoasNotPickedUp(providerId)
3194 
    return self.recv_getDoasNotPickedUp()
3195 
 
3196 
  def send_getDoasNotPickedUp(self, providerId):
3197 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3198 
    args = getDoasNotPickedUp_args()
3199 
    args.providerId = providerId
3200 
    args.write(self._oprot)
3201 
    self._oprot.writeMessageEnd()
3202 
    self._oprot.trans.flush()
3203 
 
3204 
  def recv_getDoasNotPickedUp(self, ):
3205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3206 
    if mtype == TMessageType.EXCEPTION:
3207 
      x = TApplicationException()
3208 
      x.read(self._iprot)
3209 
      self._iprot.readMessageEnd()
3210 
      raise x
3211 
    result = getDoasNotPickedUp_result()
3212 
    result.read(self._iprot)
3213 
    self._iprot.readMessageEnd()
3431 rajveer 3214 
    if result.success is not None:
2764 chandransh 3215 
      return result.success
4910 phani.kuma 3216 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3217 
 
4741 phani.kuma 3218 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3219 
    """
3220 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3221 
 
3222 
    Parameters:
3223 
     - providerId
3224 
     - pickupDetails
3225 
    """
3226 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3227 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3228 
 
3229 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3230 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3231 
    args = markReturnOrdersAsPickedUp_args()
3232 
    args.providerId = providerId
3233 
    args.pickupDetails = pickupDetails
3234 
    args.write(self._oprot)
3235 
    self._oprot.writeMessageEnd()
3236 
    self._oprot.trans.flush()
3237 
 
3238 
  def recv_markReturnOrdersAsPickedUp(self, ):
3239 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3240 
    if mtype == TMessageType.EXCEPTION:
3241 
      x = TApplicationException()
3242 
      x.read(self._iprot)
3243 
      self._iprot.readMessageEnd()
3244 
      raise x
3245 
    result = markReturnOrdersAsPickedUp_result()
3246 
    result.read(self._iprot)
3247 
    self._iprot.readMessageEnd()
4910 phani.kuma 3248 
    return
3249 
 
3250 
  def getReturnOrdersNotPickedUp(self, providerId):
3251 
    """
3252 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3253 
 
3254 
    Parameters:
3255 
     - providerId
3256 
    """
3257 
    self.send_getReturnOrdersNotPickedUp(providerId)
3258 
    return self.recv_getReturnOrdersNotPickedUp()
3259 
 
3260 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3261 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3262 
    args = getReturnOrdersNotPickedUp_args()
3263 
    args.providerId = providerId
3264 
    args.write(self._oprot)
3265 
    self._oprot.writeMessageEnd()
3266 
    self._oprot.trans.flush()
3267 
 
3268 
  def recv_getReturnOrdersNotPickedUp(self, ):
3269 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3270 
    if mtype == TMessageType.EXCEPTION:
3271 
      x = TApplicationException()
3272 
      x.read(self._iprot)
3273 
      self._iprot.readMessageEnd()
3274 
      raise x
3275 
    result = getReturnOrdersNotPickedUp_result()
3276 
    result.read(self._iprot)
3277 
    self._iprot.readMessageEnd()
4741 phani.kuma 3278 
    if result.success is not None:
3279 
      return result.success
4910 phani.kuma 3280 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3281 
 
4479 rajveer 3282 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3283 
    """
4452 rajveer 3284 
    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 3285 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3286 
    If the order is in any other state, it returns false.
3287 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3288 
 
2591 chandransh 3289 
    Parameters:
3290 
     - orderId
4479 rajveer 3291 
     - receiveCondition
2591 chandransh 3292 
    """
4479 rajveer 3293 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3294 
    return self.recv_receiveReturn()
2536 chandransh 3295 
 
4479 rajveer 3296 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3297 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3298 
    args = receiveReturn_args()
2591 chandransh 3299 
    args.orderId = orderId
4479 rajveer 3300 
    args.receiveCondition = receiveCondition
2591 chandransh 3301 
    args.write(self._oprot)
3302 
    self._oprot.writeMessageEnd()
3303 
    self._oprot.trans.flush()
3304 
 
2616 chandransh 3305 
  def recv_receiveReturn(self, ):
2591 chandransh 3306 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3307 
    if mtype == TMessageType.EXCEPTION:
3308 
      x = TApplicationException()
3309 
      x.read(self._iprot)
3310 
      self._iprot.readMessageEnd()
3311 
      raise x
2616 chandransh 3312 
    result = receiveReturn_result()
2591 chandransh 3313 
    result.read(self._iprot)
3314 
    self._iprot.readMessageEnd()
3431 rajveer 3315 
    if result.success is not None:
2591 chandransh 3316 
      return result.success
3431 rajveer 3317 
    if result.ex is not None:
2591 chandransh 3318 
      raise result.ex
2616 chandransh 3319 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3320 
 
3321 
  def validateDoa(self, orderId, isValid):
3322 
    """
4452 rajveer 3323 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3324 
    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 3325 
    If the order is in any other state, it returns false.
3326 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3327 
 
2591 chandransh 3328 
    Parameters:
3329 
     - orderId
3330 
     - isValid
3331 
    """
3332 
    self.send_validateDoa(orderId, isValid)
3333 
    return self.recv_validateDoa()
3334 
 
3335 
  def send_validateDoa(self, orderId, isValid):
3336 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3337 
    args = validateDoa_args()
3338 
    args.orderId = orderId
3339 
    args.isValid = isValid
3340 
    args.write(self._oprot)
3341 
    self._oprot.writeMessageEnd()
3342 
    self._oprot.trans.flush()
3343 
 
3344 
  def recv_validateDoa(self, ):
3345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3346 
    if mtype == TMessageType.EXCEPTION:
3347 
      x = TApplicationException()
3348 
      x.read(self._iprot)
3349 
      self._iprot.readMessageEnd()
3350 
      raise x
3351 
    result = validateDoa_result()
3352 
    result.read(self._iprot)
3353 
    self._iprot.readMessageEnd()
3431 rajveer 3354 
    if result.success is not None:
2591 chandransh 3355 
      return result.success
3431 rajveer 3356 
    if result.ex is not None:
2591 chandransh 3357 
      raise result.ex
3358 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3359 
 
4495 rajveer 3360 
  def validateReturnProduct(self, orderId, isUsable):
3361 
    """
3362 
    Parameters:
3363 
     - orderId
3364 
     - isUsable
3365 
    """
3366 
    self.send_validateReturnProduct(orderId, isUsable)
3367 
    return self.recv_validateReturnProduct()
3368 
 
3369 
  def send_validateReturnProduct(self, orderId, isUsable):
3370 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3371 
    args = validateReturnProduct_args()
3372 
    args.orderId = orderId
3373 
    args.isUsable = isUsable
3374 
    args.write(self._oprot)
3375 
    self._oprot.writeMessageEnd()
3376 
    self._oprot.trans.flush()
3377 
 
3378 
  def recv_validateReturnProduct(self, ):
3379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3380 
    if mtype == TMessageType.EXCEPTION:
3381 
      x = TApplicationException()
3382 
      x.read(self._iprot)
3383 
      self._iprot.readMessageEnd()
3384 
      raise x
3385 
    result = validateReturnProduct_result()
3386 
    result.read(self._iprot)
3387 
    self._iprot.readMessageEnd()
3388 
    if result.success is not None:
3389 
      return result.success
3390 
    if result.ex is not None:
3391 
      raise result.ex
3392 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3393 
 
2616 chandransh 3394 
  def reshipOrder(self, orderId):
3395 
    """
4484 rajveer 3396 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3397 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3398 
    	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 3399 
 
3400 
    If the order is in DOA_CERT_VALID state, it does the following:
3401 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3402 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3403 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3404 
 
2616 chandransh 3405 
    Returns the id of the newly created order.
3431 rajveer 3406 
 
2616 chandransh 3407 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3408 
 
2616 chandransh 3409 
    Parameters:
3410 
     - orderId
3411 
    """
3412 
    self.send_reshipOrder(orderId)
3413 
    return self.recv_reshipOrder()
2591 chandransh 3414 
 
2616 chandransh 3415 
  def send_reshipOrder(self, orderId):
3416 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3417 
    args = reshipOrder_args()
3418 
    args.orderId = orderId
3419 
    args.write(self._oprot)
3420 
    self._oprot.writeMessageEnd()
3421 
    self._oprot.trans.flush()
3422 
 
3423 
  def recv_reshipOrder(self, ):
3424 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3425 
    if mtype == TMessageType.EXCEPTION:
3426 
      x = TApplicationException()
3427 
      x.read(self._iprot)
3428 
      self._iprot.readMessageEnd()
3429 
      raise x
3430 
    result = reshipOrder_result()
3431 
    result.read(self._iprot)
3432 
    self._iprot.readMessageEnd()
3431 rajveer 3433 
    if result.success is not None:
2616 chandransh 3434 
      return result.success
3431 rajveer 3435 
    if result.ex is not None:
2616 chandransh 3436 
      raise result.ex
3437 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3438 
 
3226 chandransh 3439 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3440 
    """
4484 rajveer 3441 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3442 
    	1. Creates a refund request for batch processing.
3443 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3444 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3445 
 
2616 chandransh 3446 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3447 
    	1. Creates a refund request for batch processing.
3226 chandransh 3448 
    	2. Cancels the reservation of the item in the warehouse.
3449 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3450 
 
3226 chandransh 3451 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3452 
    	1. Cancels the reservation of the item in the warehouse.
3453 
    	2. Marks the current order as CANCELED.
3454 
 
3455 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3456 
 
2616 chandransh 3457 
    Returns True if it is successful, False otherwise.
3431 rajveer 3458 
 
2616 chandransh 3459 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3460 
 
2616 chandransh 3461 
    Parameters:
3462 
     - orderId
3226 chandransh 3463 
     - refundedBy
3464 
     - reason
2616 chandransh 3465 
    """
3226 chandransh 3466 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3467 
    return self.recv_refundOrder()
3468 
 
3226 chandransh 3469 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3470 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3471 
    args = refundOrder_args()
3472 
    args.orderId = orderId
3226 chandransh 3473 
    args.refundedBy = refundedBy
3474 
    args.reason = reason
2616 chandransh 3475 
    args.write(self._oprot)
3476 
    self._oprot.writeMessageEnd()
3477 
    self._oprot.trans.flush()
3478 
 
3479 
  def recv_refundOrder(self, ):
3480 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3481 
    if mtype == TMessageType.EXCEPTION:
3482 
      x = TApplicationException()
3483 
      x.read(self._iprot)
3484 
      self._iprot.readMessageEnd()
3485 
      raise x
3486 
    result = refundOrder_result()
3487 
    result.read(self._iprot)
3488 
    self._iprot.readMessageEnd()
3431 rajveer 3489 
    if result.success is not None:
2616 chandransh 3490 
      return result.success
3431 rajveer 3491 
    if result.ex is not None:
2616 chandransh 3492 
      raise result.ex
3493 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3494 
 
2690 chandransh 3495 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3496 
    """
3497 
    Get all return orders created between the from and to dates for the given warehouse.
3498 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3499 
 
2690 chandransh 3500 
    Parameters:
3501 
     - warehouseId
3502 
     - fromDate
3503 
     - toDate
3504 
    """
3505 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3506 
    return self.recv_getReturnOrders()
2616 chandransh 3507 
 
2690 chandransh 3508 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3509 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3510 
    args = getReturnOrders_args()
3511 
    args.warehouseId = warehouseId
3512 
    args.fromDate = fromDate
3513 
    args.toDate = toDate
3514 
    args.write(self._oprot)
3515 
    self._oprot.writeMessageEnd()
3516 
    self._oprot.trans.flush()
3517 
 
3518 
  def recv_getReturnOrders(self, ):
3519 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3520 
    if mtype == TMessageType.EXCEPTION:
3521 
      x = TApplicationException()
3522 
      x.read(self._iprot)
3523 
      self._iprot.readMessageEnd()
3524 
      raise x
3525 
    result = getReturnOrders_result()
3526 
    result.read(self._iprot)
3527 
    self._iprot.readMessageEnd()
3431 rajveer 3528 
    if result.success is not None:
2690 chandransh 3529 
      return result.success
3530 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3531 
 
2700 chandransh 3532 
  def getReturnOrder(self, id):
3533 
    """
3534 
    Returns the ReturnOrder corresponding to the given id.
3535 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3536 
 
2700 chandransh 3537 
    Parameters:
3538 
     - id
3539 
    """
3540 
    self.send_getReturnOrder(id)
3541 
    return self.recv_getReturnOrder()
3542 
 
3543 
  def send_getReturnOrder(self, id):
3544 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3545 
    args = getReturnOrder_args()
3546 
    args.id = id
3547 
    args.write(self._oprot)
3548 
    self._oprot.writeMessageEnd()
3549 
    self._oprot.trans.flush()
3550 
 
3551 
  def recv_getReturnOrder(self, ):
3552 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3553 
    if mtype == TMessageType.EXCEPTION:
3554 
      x = TApplicationException()
3555 
      x.read(self._iprot)
3556 
      self._iprot.readMessageEnd()
3557 
      raise x
3558 
    result = getReturnOrder_result()
3559 
    result.read(self._iprot)
3560 
    self._iprot.readMessageEnd()
3431 rajveer 3561 
    if result.success is not None:
2700 chandransh 3562 
      return result.success
3431 rajveer 3563 
    if result.ex is not None:
2700 chandransh 3564 
      raise result.ex
3565 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3566 
 
2690 chandransh 3567 
  def processReturn(self, returnOrderId):
3568 
    """
3569 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3570 
 
2690 chandransh 3571 
    Parameters:
3572 
     - returnOrderId
3573 
    """
3574 
    self.send_processReturn(returnOrderId)
3575 
    self.recv_processReturn()
3576 
 
3577 
  def send_processReturn(self, returnOrderId):
3578 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3579 
    args = processReturn_args()
3580 
    args.returnOrderId = returnOrderId
3581 
    args.write(self._oprot)
3582 
    self._oprot.writeMessageEnd()
3583 
    self._oprot.trans.flush()
3584 
 
3585 
  def recv_processReturn(self, ):
3586 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3587 
    if mtype == TMessageType.EXCEPTION:
3588 
      x = TApplicationException()
3589 
      x.read(self._iprot)
3590 
      self._iprot.readMessageEnd()
3591 
      raise x
3592 
    result = processReturn_result()
3593 
    result.read(self._iprot)
3594 
    self._iprot.readMessageEnd()
3431 rajveer 3595 
    if result.ex is not None:
2690 chandransh 3596 
      raise result.ex
3597 
    return
3598 
 
3451 chandransh 3599 
  def updateWeight(self, orderId, weight):
3600 
    """
3601 
    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 3602 
 
3451 chandransh 3603 
    Parameters:
3604 
     - orderId
3605 
     - weight
3606 
    """
3607 
    self.send_updateWeight(orderId, weight)
3608 
    return self.recv_updateWeight()
3609 
 
3610 
  def send_updateWeight(self, orderId, weight):
3611 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3612 
    args = updateWeight_args()
3613 
    args.orderId = orderId
3614 
    args.weight = weight
3615 
    args.write(self._oprot)
3616 
    self._oprot.writeMessageEnd()
3617 
    self._oprot.trans.flush()
3618 
 
3619 
  def recv_updateWeight(self, ):
3620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3621 
    if mtype == TMessageType.EXCEPTION:
3622 
      x = TApplicationException()
3623 
      x.read(self._iprot)
3624 
      self._iprot.readMessageEnd()
3625 
      raise x
3626 
    result = updateWeight_result()
3627 
    result.read(self._iprot)
3628 
    self._iprot.readMessageEnd()
3629 
    if result.success is not None:
3630 
      return result.success
3631 
    if result.ex is not None:
3632 
      raise result.ex
3633 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3634 
 
3469 chandransh 3635 
  def changeItem(self, orderId, itemId):
3636 
    """
3637 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3638 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3639 
 
3469 chandransh 3640 
    Parameters:
3641 
     - orderId
3642 
     - itemId
3643 
    """
3644 
    self.send_changeItem(orderId, itemId)
3645 
    return self.recv_changeItem()
3646 
 
3647 
  def send_changeItem(self, orderId, itemId):
3648 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3649 
    args = changeItem_args()
3650 
    args.orderId = orderId
3651 
    args.itemId = itemId
3652 
    args.write(self._oprot)
3653 
    self._oprot.writeMessageEnd()
3654 
    self._oprot.trans.flush()
3655 
 
3656 
  def recv_changeItem(self, ):
3657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3658 
    if mtype == TMessageType.EXCEPTION:
3659 
      x = TApplicationException()
3660 
      x.read(self._iprot)
3661 
      self._iprot.readMessageEnd()
3662 
      raise x
3663 
    result = changeItem_result()
3664 
    result.read(self._iprot)
3665 
    self._iprot.readMessageEnd()
3666 
    if result.success is not None:
3667 
      return result.success
3668 
    if result.ex is not None:
3669 
      raise result.ex
3670 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3671 
 
3672 
  def shiftToWarehouse(self, orderId, warehouseId):
3673 
    """
3674 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3675 
 
3676 
    Parameters:
3677 
     - orderId
3678 
     - warehouseId
3679 
    """
3680 
    self.send_shiftToWarehouse(orderId, warehouseId)
3681 
    return self.recv_shiftToWarehouse()
3682 
 
3683 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3684 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3685 
    args = shiftToWarehouse_args()
3686 
    args.orderId = orderId
3687 
    args.warehouseId = warehouseId
3688 
    args.write(self._oprot)
3689 
    self._oprot.writeMessageEnd()
3690 
    self._oprot.trans.flush()
3691 
 
3692 
  def recv_shiftToWarehouse(self, ):
3693 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3694 
    if mtype == TMessageType.EXCEPTION:
3695 
      x = TApplicationException()
3696 
      x.read(self._iprot)
3697 
      self._iprot.readMessageEnd()
3698 
      raise x
3699 
    result = shiftToWarehouse_result()
3700 
    result.read(self._iprot)
3701 
    self._iprot.readMessageEnd()
3702 
    if result.success is not None:
3703 
      return result.success
3704 
    if result.ex is not None:
3705 
      raise result.ex
3706 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3707 
 
4647 rajveer 3708 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3709 
    """
3710 
    Adds the given delay reason to the given order.
3986 chandransh 3711 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3712 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3713 
 
3553 chandransh 3714 
    Parameters:
3715 
     - orderId
3716 
     - delayReason
3986 chandransh 3717 
     - furtherDelay
4647 rajveer 3718 
     - delayReasonText
3553 chandransh 3719 
    """
4647 rajveer 3720 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3721 
    return self.recv_addDelayReason()
3722 
 
4647 rajveer 3723 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3724 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3725 
    args = addDelayReason_args()
3726 
    args.orderId = orderId
3727 
    args.delayReason = delayReason
3986 chandransh 3728 
    args.furtherDelay = furtherDelay
4647 rajveer 3729 
    args.delayReasonText = delayReasonText
3553 chandransh 3730 
    args.write(self._oprot)
3731 
    self._oprot.writeMessageEnd()
3732 
    self._oprot.trans.flush()
3733 
 
3734 
  def recv_addDelayReason(self, ):
3735 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3736 
    if mtype == TMessageType.EXCEPTION:
3737 
      x = TApplicationException()
3738 
      x.read(self._iprot)
3739 
      self._iprot.readMessageEnd()
3740 
      raise x
3741 
    result = addDelayReason_result()
3742 
    result.read(self._iprot)
3743 
    self._iprot.readMessageEnd()
3744 
    if result.success is not None:
3745 
      return result.success
3746 
    if result.ex is not None:
3747 
      raise result.ex
3748 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3749 
 
3956 chandransh 3750 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3751 
    """
3752 
    Marks the COD orders with given AWB nos. as having been processed.
3753 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3754 
 
3956 chandransh 3755 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3756 
    1. There is no order corresponding to an AWB number.
3757 
    2. The captured amount for a payment exceeds the total payment.
3758 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3759 
 
3760 
    Parameters:
3761 
     - collectedAmountMap
3762 
     - xferBy
3763 
     - xferTxnId
3764 
     - xferDate
3765 
    """
3766 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3767 
    return self.recv_reconcileCodCollection()
3768 
 
3769 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3770 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3771 
    args = reconcileCodCollection_args()
3772 
    args.collectedAmountMap = collectedAmountMap
3773 
    args.xferBy = xferBy
3774 
    args.xferTxnId = xferTxnId
3775 
    args.xferDate = xferDate
3776 
    args.write(self._oprot)
3777 
    self._oprot.writeMessageEnd()
3778 
    self._oprot.trans.flush()
3779 
 
3780 
  def recv_reconcileCodCollection(self, ):
3781 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3782 
    if mtype == TMessageType.EXCEPTION:
3783 
      x = TApplicationException()
3784 
      x.read(self._iprot)
3785 
      self._iprot.readMessageEnd()
3786 
      raise x
3787 
    result = reconcileCodCollection_result()
3788 
    result.read(self._iprot)
3789 
    self._iprot.readMessageEnd()
3790 
    if result.success is not None:
3791 
      return result.success
3792 
    if result.ex is not None:
3793 
      raise result.ex
3794 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3795 
 
4008 mandeep.dh 3796 
  def getTransactionsRequiringExtraProcessing(self, category):
3797 
    """
4065 mandeep.dh 3798 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3799 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3800 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3801 
 
4008 mandeep.dh 3802 
    Parameters:
3803 
     - category
3804 
    """
3805 
    self.send_getTransactionsRequiringExtraProcessing(category)
3806 
    return self.recv_getTransactionsRequiringExtraProcessing()
3807 
 
3808 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3809 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3810 
    args = getTransactionsRequiringExtraProcessing_args()
3811 
    args.category = category
3812 
    args.write(self._oprot)
3813 
    self._oprot.writeMessageEnd()
3814 
    self._oprot.trans.flush()
3815 
 
3816 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3818 
    if mtype == TMessageType.EXCEPTION:
3819 
      x = TApplicationException()
3820 
      x.read(self._iprot)
3821 
      self._iprot.readMessageEnd()
3822 
      raise x
3823 
    result = getTransactionsRequiringExtraProcessing_result()
3824 
    result.read(self._iprot)
3825 
    self._iprot.readMessageEnd()
3826 
    if result.success is not None:
3827 
      return result.success
3828 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3829 
 
3830 
  def markTransactionAsProcessed(self, transactionId, category):
3831 
    """
3832 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3833 
    It essentially deletes the transaction id record for a particular
3834 
    processing type category (if present) from DB.
3835 
    This is currently used by CRM application.
4008 mandeep.dh 3836 
 
3837 
    Parameters:
3838 
     - transactionId
3839 
     - category
3840 
    """
3841 
    self.send_markTransactionAsProcessed(transactionId, category)
3842 
    self.recv_markTransactionAsProcessed()
3843 
 
3844 
  def send_markTransactionAsProcessed(self, transactionId, category):
3845 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3846 
    args = markTransactionAsProcessed_args()
3847 
    args.transactionId = transactionId
3848 
    args.category = category
3849 
    args.write(self._oprot)
3850 
    self._oprot.writeMessageEnd()
3851 
    self._oprot.trans.flush()
3852 
 
3853 
  def recv_markTransactionAsProcessed(self, ):
3854 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3855 
    if mtype == TMessageType.EXCEPTION:
3856 
      x = TApplicationException()
3857 
      x.read(self._iprot)
3858 
      self._iprot.readMessageEnd()
3859 
      raise x
3860 
    result = markTransactionAsProcessed_result()
3861 
    result.read(self._iprot)
3862 
    self._iprot.readMessageEnd()
3863 
    return
3864 
 
4018 chandransh 3865 
  def getItemWiseRiskyOrdersCount(self, ):
3866 
    """
3867 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3868 
    is defined as one whose shipping date is about to expire.
3869 
    """
3870 
    self.send_getItemWiseRiskyOrdersCount()
3871 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3872 
 
4018 chandransh 3873 
  def send_getItemWiseRiskyOrdersCount(self, ):
3874 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3875 
    args = getItemWiseRiskyOrdersCount_args()
3876 
    args.write(self._oprot)
3877 
    self._oprot.writeMessageEnd()
3878 
    self._oprot.trans.flush()
3879 
 
3880 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3881 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3882 
    if mtype == TMessageType.EXCEPTION:
3883 
      x = TApplicationException()
3884 
      x.read(self._iprot)
3885 
      self._iprot.readMessageEnd()
3886 
      raise x
3887 
    result = getItemWiseRiskyOrdersCount_result()
3888 
    result.read(self._iprot)
3889 
    self._iprot.readMessageEnd()
3890 
    if result.success is not None:
3891 
      return result.success
3892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3893 
 
4295 varun.gupt 3894 
  def getOrdersForItemIds(self, itemIds):
3895 
    """
3896 
    Returns a list of all orders which have items with given id
3897 
 
3898 
    Parameters:
3899 
     - itemIds
3900 
    """
3901 
    self.send_getOrdersForItemIds(itemIds)
3902 
    return self.recv_getOrdersForItemIds()
3903 
 
3904 
  def send_getOrdersForItemIds(self, itemIds):
3905 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3906 
    args = getOrdersForItemIds_args()
3907 
    args.itemIds = itemIds
3908 
    args.write(self._oprot)
3909 
    self._oprot.writeMessageEnd()
3910 
    self._oprot.trans.flush()
3911 
 
3912 
  def recv_getOrdersForItemIds(self, ):
3913 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3914 
    if mtype == TMessageType.EXCEPTION:
3915 
      x = TApplicationException()
3916 
      x.read(self._iprot)
3917 
      self._iprot.readMessageEnd()
3918 
      raise x
3919 
    result = getOrdersForItemIds_result()
3920 
    result.read(self._iprot)
3921 
    self._iprot.readMessageEnd()
3922 
    if result.success is not None:
3923 
      return result.success
3924 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3925 
 
4247 rajveer 3926 
  def markOrderCancellationRequestReceived(self, orderId):
3927 
    """
3928 
    Mark order as cancellation request received. If customer sends request of cancellation of
3929 
    a particular order, this method will be called. It will just change status of the order
3930 
    depending on its current status. It also records the previous status, so that we can move
3931 
    back to that status if cancellation request is denied.
4018 chandransh 3932 
 
4247 rajveer 3933 
    Parameters:
3934 
     - orderId
3935 
    """
3936 
    self.send_markOrderCancellationRequestReceived(orderId)
3937 
    self.recv_markOrderCancellationRequestReceived()
3938 
 
3939 
  def send_markOrderCancellationRequestReceived(self, orderId):
3940 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3941 
    args = markOrderCancellationRequestReceived_args()
3942 
    args.orderId = orderId
3943 
    args.write(self._oprot)
3944 
    self._oprot.writeMessageEnd()
3945 
    self._oprot.trans.flush()
3946 
 
3947 
  def recv_markOrderCancellationRequestReceived(self, ):
3948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3949 
    if mtype == TMessageType.EXCEPTION:
3950 
      x = TApplicationException()
3951 
      x.read(self._iprot)
3952 
      self._iprot.readMessageEnd()
3953 
      raise x
3954 
    result = markOrderCancellationRequestReceived_result()
3955 
    result.read(self._iprot)
3956 
    self._iprot.readMessageEnd()
3957 
    if result.ex is not None:
3958 
      raise result.ex
3959 
    return
3960 
 
3961 
  def markOrderCancellationRequestConfirmed(self, orderId):
3962 
    """
3963 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3964 
    cancellation request confirmed. After this OM will be able to cancel the order.
3965 
 
3966 
    Parameters:
3967 
     - orderId
3968 
    """
3969 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3970 
    self.recv_markOrderCancellationRequestConfirmed()
3971 
 
3972 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3973 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3974 
    args = markOrderCancellationRequestConfirmed_args()
3975 
    args.orderId = orderId
3976 
    args.write(self._oprot)
3977 
    self._oprot.writeMessageEnd()
3978 
    self._oprot.trans.flush()
3979 
 
3980 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3982 
    if mtype == TMessageType.EXCEPTION:
3983 
      x = TApplicationException()
3984 
      x.read(self._iprot)
3985 
      self._iprot.readMessageEnd()
3986 
      raise x
3987 
    result = markOrderCancellationRequestConfirmed_result()
3988 
    result.read(self._iprot)
3989 
    self._iprot.readMessageEnd()
3990 
    if result.ex is not None:
3991 
      raise result.ex
3992 
    return
3993 
 
3994 
  def markOrderCancellationRequestDenied(self, orderId):
3995 
    """
3996 
    If we decide to not to cancel order, we will move the order ro previous status.
3997 
 
3998 
    Parameters:
3999 
     - orderId
4000 
    """
4001 
    self.send_markOrderCancellationRequestDenied(orderId)
4002 
    self.recv_markOrderCancellationRequestDenied()
4003 
 
4004 
  def send_markOrderCancellationRequestDenied(self, orderId):
4005 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4006 
    args = markOrderCancellationRequestDenied_args()
4007 
    args.orderId = orderId
4008 
    args.write(self._oprot)
4009 
    self._oprot.writeMessageEnd()
4010 
    self._oprot.trans.flush()
4011 
 
4012 
  def recv_markOrderCancellationRequestDenied(self, ):
4013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4014 
    if mtype == TMessageType.EXCEPTION:
4015 
      x = TApplicationException()
4016 
      x.read(self._iprot)
4017 
      self._iprot.readMessageEnd()
4018 
      raise x
4019 
    result = markOrderCancellationRequestDenied_result()
4020 
    result.read(self._iprot)
4021 
    self._iprot.readMessageEnd()
4022 
    if result.ex is not None:
4023 
      raise result.ex
4024 
    return
4025 
 
4258 rajveer 4026 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4027 
    """
4258 rajveer 4028 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4029 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4030 
 
4031 
    Parameters:
4258 rajveer 4032 
     - transactionId
4247 rajveer 4033 
    """
4258 rajveer 4034 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4035 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4036 
 
4258 rajveer 4037 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4038 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4039 
    args = markTransactionAsPaymentFlagRemoved_args()
4040 
    args.transactionId = transactionId
4247 rajveer 4041 
    args.write(self._oprot)
4042 
    self._oprot.writeMessageEnd()
4043 
    self._oprot.trans.flush()
4044 
 
4258 rajveer 4045 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4046 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4047 
    if mtype == TMessageType.EXCEPTION:
4048 
      x = TApplicationException()
4049 
      x.read(self._iprot)
4050 
      self._iprot.readMessageEnd()
4051 
      raise x
4258 rajveer 4052 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4053 
    result.read(self._iprot)
4054 
    self._iprot.readMessageEnd()
4055 
    if result.ex is not None:
4056 
      raise result.ex
4057 
    return
4058 
 
4259 anupam.sin 4059 
  def refundTransaction(self, transactionId, refundedBy, reason):
4060 
    """
4061 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4062 
    need to be cancelled
4247 rajveer 4063 
 
4259 anupam.sin 4064 
    Parameters:
4065 
     - transactionId
4066 
     - refundedBy
4067 
     - reason
4068 
    """
4069 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4070 
    self.recv_refundTransaction()
4071 
 
4072 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4073 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4074 
    args = refundTransaction_args()
4075 
    args.transactionId = transactionId
4076 
    args.refundedBy = refundedBy
4077 
    args.reason = reason
4078 
    args.write(self._oprot)
4079 
    self._oprot.writeMessageEnd()
4080 
    self._oprot.trans.flush()
4081 
 
4082 
  def recv_refundTransaction(self, ):
4083 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4084 
    if mtype == TMessageType.EXCEPTION:
4085 
      x = TApplicationException()
4086 
      x.read(self._iprot)
4087 
      self._iprot.readMessageEnd()
4088 
      raise x
4089 
    result = refundTransaction_result()
4090 
    result.read(self._iprot)
4091 
    self._iprot.readMessageEnd()
4092 
    if result.ex is not None:
4093 
      raise result.ex
4094 
    return
4095 
 
4324 mandeep.dh 4096 
  def updateShipmentAddress(self, orderId, addressId):
4097 
    """
4098 
    Updates shipment address of an order. Delivery and shipping date estimates
4099 
    etc. are also updated here.
4100 
 
4101 
    Throws TransactionServiceException in case address change is not
4102 
    possible due to certain reasons such as new pincode in address is
4103 
    not serviceable etc.
4104 
 
4105 
    Parameters:
4106 
     - orderId
4107 
     - addressId
4108 
    """
4109 
    self.send_updateShipmentAddress(orderId, addressId)
4110 
    self.recv_updateShipmentAddress()
4111 
 
4112 
  def send_updateShipmentAddress(self, orderId, addressId):
4113 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4114 
    args = updateShipmentAddress_args()
4115 
    args.orderId = orderId
4116 
    args.addressId = addressId
4117 
    args.write(self._oprot)
4118 
    self._oprot.writeMessageEnd()
4119 
    self._oprot.trans.flush()
4120 
 
4121 
  def recv_updateShipmentAddress(self, ):
4122 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4123 
    if mtype == TMessageType.EXCEPTION:
4124 
      x = TApplicationException()
4125 
      x.read(self._iprot)
4126 
      self._iprot.readMessageEnd()
4127 
      raise x
4128 
    result = updateShipmentAddress_result()
4129 
    result.read(self._iprot)
4130 
    self._iprot.readMessageEnd()
4131 
    if result.ex is not None:
4132 
      raise result.ex
4133 
    return
4134 
 
4285 rajveer 4135 
  def acceptOrdersForItemId(self, itemId, inventory):
4136 
    """
4137 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4138 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4139 
 
4285 rajveer 4140 
    Parameters:
4141 
     - itemId
4142 
     - inventory
4143 
    """
4144 
    self.send_acceptOrdersForItemId(itemId, inventory)
4145 
    return self.recv_acceptOrdersForItemId()
4146 
 
4147 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4148 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4149 
    args = acceptOrdersForItemId_args()
4150 
    args.itemId = itemId
4151 
    args.inventory = inventory
4152 
    args.write(self._oprot)
4153 
    self._oprot.writeMessageEnd()
4154 
    self._oprot.trans.flush()
4155 
 
4156 
  def recv_acceptOrdersForItemId(self, ):
4157 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4158 
    if mtype == TMessageType.EXCEPTION:
4159 
      x = TApplicationException()
4160 
      x.read(self._iprot)
4161 
      self._iprot.readMessageEnd()
4162 
      raise x
4163 
    result = acceptOrdersForItemId_result()
4164 
    result.read(self._iprot)
4165 
    self._iprot.readMessageEnd()
4166 
    if result.success is not None:
4167 
      return result.success
4168 
    if result.ex is not None:
4169 
      raise result.ex
4170 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4171 
 
4369 rajveer 4172 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4173 
    """
4174 
    Parameters:
4175 
     - vendorId
4176 
     - itemId
4177 
     - quantity
4178 
     - estimate
4369 rajveer 4179 
     - isReminder
4303 rajveer 4180 
    """
4369 rajveer 4181 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4182 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4183 
 
4369 rajveer 4184 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4185 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4186 
    args = markOrdersAsPORaised_args()
4187 
    args.vendorId = vendorId
4188 
    args.itemId = itemId
4189 
    args.quantity = quantity
4190 
    args.estimate = estimate
4369 rajveer 4191 
    args.isReminder = isReminder
4303 rajveer 4192 
    args.write(self._oprot)
4193 
    self._oprot.writeMessageEnd()
4194 
    self._oprot.trans.flush()
4195 
 
4196 
  def recv_markOrdersAsPORaised(self, ):
4197 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4198 
    if mtype == TMessageType.EXCEPTION:
4199 
      x = TApplicationException()
4200 
      x.read(self._iprot)
4201 
      self._iprot.readMessageEnd()
4202 
      raise x
4203 
    result = markOrdersAsPORaised_result()
4204 
    result.read(self._iprot)
4205 
    self._iprot.readMessageEnd()
4206 
    if result.ex is not None:
4207 
      raise result.ex
4208 
    return
4209 
 
4369 rajveer 4210 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4211 
    """
4212 
    Parameters:
4213 
     - vendorId
4214 
     - itemId
4215 
     - quantity
4216 
     - estimate
4369 rajveer 4217 
     - isReminder
4303 rajveer 4218 
    """
4369 rajveer 4219 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4220 
    self.recv_markOrdersAsReversalInitiated()
4221 
 
4369 rajveer 4222 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4223 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4224 
    args = markOrdersAsReversalInitiated_args()
4225 
    args.vendorId = vendorId
4226 
    args.itemId = itemId
4227 
    args.quantity = quantity
4228 
    args.estimate = estimate
4369 rajveer 4229 
    args.isReminder = isReminder
4303 rajveer 4230 
    args.write(self._oprot)
4231 
    self._oprot.writeMessageEnd()
4232 
    self._oprot.trans.flush()
4233 
 
4234 
  def recv_markOrdersAsReversalInitiated(self, ):
4235 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4236 
    if mtype == TMessageType.EXCEPTION:
4237 
      x = TApplicationException()
4238 
      x.read(self._iprot)
4239 
      self._iprot.readMessageEnd()
4240 
      raise x
4241 
    result = markOrdersAsReversalInitiated_result()
4242 
    result.read(self._iprot)
4243 
    self._iprot.readMessageEnd()
4244 
    if result.ex is not None:
4245 
      raise result.ex
4246 
    return
4247 
 
4369 rajveer 4248 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4249 
    """
4250 
    Parameters:
4251 
     - vendorId
4252 
     - itemId
4253 
     - quantity
4254 
     - estimate
4369 rajveer 4255 
     - isReminder
4303 rajveer 4256 
    """
4369 rajveer 4257 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4258 
    self.recv_markOrdersAsNotAvailabke()
4259 
 
4369 rajveer 4260 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4261 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4262 
    args = markOrdersAsNotAvailabke_args()
4263 
    args.vendorId = vendorId
4264 
    args.itemId = itemId
4265 
    args.quantity = quantity
4266 
    args.estimate = estimate
4369 rajveer 4267 
    args.isReminder = isReminder
4303 rajveer 4268 
    args.write(self._oprot)
4269 
    self._oprot.writeMessageEnd()
4270 
    self._oprot.trans.flush()
4271 
 
4272 
  def recv_markOrdersAsNotAvailabke(self, ):
4273 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4274 
    if mtype == TMessageType.EXCEPTION:
4275 
      x = TApplicationException()
4276 
      x.read(self._iprot)
4277 
      self._iprot.readMessageEnd()
4278 
      raise x
4279 
    result = markOrdersAsNotAvailabke_result()
4280 
    result.read(self._iprot)
4281 
    self._iprot.readMessageEnd()
4282 
    if result.ex is not None:
4283 
      raise result.ex
4284 
    return
4285 
 
4369 rajveer 4286 
  def markOrdersAsTimeout(self, vendorId):
4287 
    """
4288 
    Parameters:
4289 
     - vendorId
4290 
    """
4291 
    self.send_markOrdersAsTimeout(vendorId)
4292 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4293 
 
4369 rajveer 4294 
  def send_markOrdersAsTimeout(self, vendorId):
4295 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4296 
    args = markOrdersAsTimeout_args()
4297 
    args.vendorId = vendorId
4298 
    args.write(self._oprot)
4299 
    self._oprot.writeMessageEnd()
4300 
    self._oprot.trans.flush()
4301 
 
4302 
  def recv_markOrdersAsTimeout(self, ):
4303 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4304 
    if mtype == TMessageType.EXCEPTION:
4305 
      x = TApplicationException()
4306 
      x.read(self._iprot)
4307 
      self._iprot.readMessageEnd()
4308 
      raise x
4309 
    result = markOrdersAsTimeout_result()
4310 
    result.read(self._iprot)
4311 
    self._iprot.readMessageEnd()
4312 
    if result.success is not None:
4313 
      return result.success
4314 
    if result.ex is not None:
4315 
      raise result.ex
4316 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4317 
 
4662 rajveer 4318 
  def markOrderAsLostInTransit(self, orderId):
4319 
    """
4320 
    Mark order as LOST_IN_TRANSIT
4321 
 
4322 
    Parameters:
4323 
     - orderId
4324 
    """
4325 
    self.send_markOrderAsLostInTransit(orderId)
4326 
    return self.recv_markOrderAsLostInTransit()
4327 
 
4328 
  def send_markOrderAsLostInTransit(self, orderId):
4329 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4330 
    args = markOrderAsLostInTransit_args()
4331 
    args.orderId = orderId
4332 
    args.write(self._oprot)
4333 
    self._oprot.writeMessageEnd()
4334 
    self._oprot.trans.flush()
4335 
 
4336 
  def recv_markOrderAsLostInTransit(self, ):
4337 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4338 
    if mtype == TMessageType.EXCEPTION:
4339 
      x = TApplicationException()
4340 
      x.read(self._iprot)
4341 
      self._iprot.readMessageEnd()
4342 
      raise x
4343 
    result = markOrderAsLostInTransit_result()
4344 
    result.read(self._iprot)
4345 
    self._iprot.readMessageEnd()
4346 
    if result.success is not None:
4347 
      return result.success
4348 
    if result.ex is not None:
4349 
      raise result.ex
4350 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4351 
 
4386 anupam.sin 4352 
  def getOrderForAwb(self, awb):
4353 
    """
4354 
    Returns the order corresponding to an AWB number
4369 rajveer 4355 
 
4386 anupam.sin 4356 
    Parameters:
4357 
     - awb
4358 
    """
4359 
    self.send_getOrderForAwb(awb)
4360 
    return self.recv_getOrderForAwb()
4361 
 
4362 
  def send_getOrderForAwb(self, awb):
4363 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4364 
    args = getOrderForAwb_args()
4365 
    args.awb = awb
4366 
    args.write(self._oprot)
4367 
    self._oprot.writeMessageEnd()
4368 
    self._oprot.trans.flush()
4369 
 
4370 
  def recv_getOrderForAwb(self, ):
4371 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4372 
    if mtype == TMessageType.EXCEPTION:
4373 
      x = TApplicationException()
4374 
      x.read(self._iprot)
4375 
      self._iprot.readMessageEnd()
4376 
      raise x
4377 
    result = getOrderForAwb_result()
4378 
    result.read(self._iprot)
4379 
    self._iprot.readMessageEnd()
4380 
    if result.success is not None:
4381 
      return result.success
4382 
    if result.ex is not None:
4383 
      raise result.ex
4384 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4385 
 
4910 phani.kuma 4386 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4387 
    """
4910 phani.kuma 4388 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4389 
 
4506 phani.kuma 4390 
    Parameters:
4391 
     - logistics_provider_id
4910 phani.kuma 4392 
     - order_status_list
4506 phani.kuma 4393 
    """
4910 phani.kuma 4394 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4395 
    return self.recv_getOrdersForProviderForStatus()
4396 
 
4910 phani.kuma 4397 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4398 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4399 
    args = getOrdersForProviderForStatus_args()
4400 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4401 
    args.order_status_list = order_status_list
4506 phani.kuma 4402 
    args.write(self._oprot)
4403 
    self._oprot.writeMessageEnd()
4404 
    self._oprot.trans.flush()
4405 
 
4406 
  def recv_getOrdersForProviderForStatus(self, ):
4407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4408 
    if mtype == TMessageType.EXCEPTION:
4409 
      x = TApplicationException()
4410 
      x.read(self._iprot)
4411 
      self._iprot.readMessageEnd()
4412 
      raise x
4413 
    result = getOrdersForProviderForStatus_result()
4414 
    result.read(self._iprot)
4415 
    self._iprot.readMessageEnd()
4416 
    if result.success is not None:
4417 
      return result.success
4418 
    if result.ex is not None:
4419 
      raise result.ex
4420 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4421 
 
4600 varun.gupt 4422 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4423 
    """
4424 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4425 
 
4600 varun.gupt 4426 
    Parameters:
4427 
     - vendorId
4428 
     - billingDateFrom
4429 
     - billingDateTo
4430 
    """
4431 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4432 
    return self.recv_getBilledOrdersForVendor()
4433 
 
4434 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4435 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4436 
    args = getBilledOrdersForVendor_args()
4437 
    args.vendorId = vendorId
4438 
    args.billingDateFrom = billingDateFrom
4439 
    args.billingDateTo = billingDateTo
4440 
    args.write(self._oprot)
4441 
    self._oprot.writeMessageEnd()
4442 
    self._oprot.trans.flush()
4443 
 
4444 
  def recv_getBilledOrdersForVendor(self, ):
4445 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4446 
    if mtype == TMessageType.EXCEPTION:
4447 
      x = TApplicationException()
4448 
      x.read(self._iprot)
4449 
      self._iprot.readMessageEnd()
4450 
      raise x
4451 
    result = getBilledOrdersForVendor_result()
4452 
    result.read(self._iprot)
4453 
    self._iprot.readMessageEnd()
4454 
    if result.success is not None:
4455 
      return result.success
4456 
    if result.ex is not None:
4457 
      raise result.ex
4458 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4459 
 
4607 rajveer 4460 
  def getSlippedSippingDateOrders(self, ):
4461 
    self.send_getSlippedSippingDateOrders()
4462 
    return self.recv_getSlippedSippingDateOrders()
4463 
 
4464 
  def send_getSlippedSippingDateOrders(self, ):
4465 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4466 
    args = getSlippedSippingDateOrders_args()
4467 
    args.write(self._oprot)
4468 
    self._oprot.writeMessageEnd()
4469 
    self._oprot.trans.flush()
4470 
 
4471 
  def recv_getSlippedSippingDateOrders(self, ):
4472 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4473 
    if mtype == TMessageType.EXCEPTION:
4474 
      x = TApplicationException()
4475 
      x.read(self._iprot)
4476 
      self._iprot.readMessageEnd()
4477 
      raise x
4478 
    result = getSlippedSippingDateOrders_result()
4479 
    result.read(self._iprot)
4480 
    self._iprot.readMessageEnd()
4481 
    if result.success is not None:
4482 
      return result.success
4483 
    if result.ex is not None:
4484 
      raise result.ex
4485 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4486 
 
4709 rajveer 4487 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4488 
    """
4489 
    Parameters:
4490 
     - cancelDateFrom
4491 
     - cancelDateTo
4492 
    """
4493 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4494 
    return self.recv_getCancelledOrders()
4495 
 
4496 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4497 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4498 
    args = getCancelledOrders_args()
4499 
    args.cancelDateFrom = cancelDateFrom
4500 
    args.cancelDateTo = cancelDateTo
4501 
    args.write(self._oprot)
4502 
    self._oprot.writeMessageEnd()
4503 
    self._oprot.trans.flush()
4504 
 
4505 
  def recv_getCancelledOrders(self, ):
4506 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4507 
    if mtype == TMessageType.EXCEPTION:
4508 
      x = TApplicationException()
4509 
      x.read(self._iprot)
4510 
      self._iprot.readMessageEnd()
4511 
      raise x
4512 
    result = getCancelledOrders_result()
4513 
    result.read(self._iprot)
4514 
    self._iprot.readMessageEnd()
4515 
    if result.success is not None:
4516 
      return result.success
4517 
    if result.ex is not None:
4518 
      raise result.ex
4519 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4520 
 
4600 varun.gupt 4521 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4522 
    """
4523 
    Parameters:
4524 
     - mapAWBAndAmount
4525 
    """
4526 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4527 
    self.recv_saveBluedartSettlements()
4528 
 
4529 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4530 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4531 
    args = saveBluedartSettlements_args()
4532 
    args.mapAWBAndAmount = mapAWBAndAmount
4533 
    args.write(self._oprot)
4534 
    self._oprot.writeMessageEnd()
4535 
    self._oprot.trans.flush()
4536 
 
4537 
  def recv_saveBluedartSettlements(self, ):
4538 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4539 
    if mtype == TMessageType.EXCEPTION:
4540 
      x = TApplicationException()
4541 
      x.read(self._iprot)
4542 
      self._iprot.readMessageEnd()
4543 
      raise x
4544 
    result = saveBluedartSettlements_result()
4545 
    result.read(self._iprot)
4546 
    self._iprot.readMessageEnd()
4547 
    if result.ex is not None:
4548 
      raise result.ex
4549 
    return
4550 
 
4905 varun.gupt 4551 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4552 
    """
4553 
    Parameters:
4554 
     - settlementDate
4555 
     - paymentGatewayId
4905 varun.gupt 4556 
     - referenceId
4600 varun.gupt 4557 
     - serviceTax
4558 
     - otherCharges
4559 
     - netCollection
4560 
    """
4905 varun.gupt 4561 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4562 
    self.recv_savePaymentSettlements()
4563 
 
4905 varun.gupt 4564 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4565 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4566 
    args = savePaymentSettlements_args()
4567 
    args.settlementDate = settlementDate
4568 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4569 
    args.referenceId = referenceId
4600 varun.gupt 4570 
    args.serviceTax = serviceTax
4571 
    args.otherCharges = otherCharges
4572 
    args.netCollection = netCollection
4573 
    args.write(self._oprot)
4574 
    self._oprot.writeMessageEnd()
4575 
    self._oprot.trans.flush()
4576 
 
4577 
  def recv_savePaymentSettlements(self, ):
4578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4579 
    if mtype == TMessageType.EXCEPTION:
4580 
      x = TApplicationException()
4581 
      x.read(self._iprot)
4582 
      self._iprot.readMessageEnd()
4583 
      raise x
4584 
    result = savePaymentSettlements_result()
4585 
    result.read(self._iprot)
4586 
    self._iprot.readMessageEnd()
4587 
    if result.ex is not None:
4588 
      raise result.ex
4589 
    return
4590 
 
4591 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4592 
    """
4593 
    Parameters:
4594 
     - settlementId
4595 
     - settlementDate
4596 
     - transactionDateFrom
4597 
     - transactionDateTo
4598 
     - amount
4599 
    """
4600 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4601 
    self.recv_saveEBSSettlementSummary()
4602 
 
4603 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4604 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4605 
    args = saveEBSSettlementSummary_args()
4606 
    args.settlementId = settlementId
4607 
    args.settlementDate = settlementDate
4608 
    args.transactionDateFrom = transactionDateFrom
4609 
    args.transactionDateTo = transactionDateTo
4610 
    args.amount = amount
4611 
    args.write(self._oprot)
4612 
    self._oprot.writeMessageEnd()
4613 
    self._oprot.trans.flush()
4614 
 
4615 
  def recv_saveEBSSettlementSummary(self, ):
4616 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4617 
    if mtype == TMessageType.EXCEPTION:
4618 
      x = TApplicationException()
4619 
      x.read(self._iprot)
4620 
      self._iprot.readMessageEnd()
4621 
      raise x
4622 
    result = saveEBSSettlementSummary_result()
4623 
    result.read(self._iprot)
4624 
    self._iprot.readMessageEnd()
4625 
    if result.ex is not None:
4626 
      raise result.ex
4627 
    return
4628 
 
5189 varun.gupt 4629 
  def getSettlementForReferenceId(self, referenceId, isRefund):
4600 varun.gupt 4630 
    """
4631 
    Parameters:
5189 varun.gupt 4632 
     - referenceId
4633 
     - isRefund
4600 varun.gupt 4634 
    """
5189 varun.gupt 4635 
    self.send_getSettlementForReferenceId(referenceId, isRefund)
4636 
    return self.recv_getSettlementForReferenceId()
4600 varun.gupt 4637 
 
5189 varun.gupt 4638 
  def send_getSettlementForReferenceId(self, referenceId, isRefund):
4639 
    self._oprot.writeMessageBegin('getSettlementForReferenceId', TMessageType.CALL, self._seqid)
4640 
    args = getSettlementForReferenceId_args()
4641 
    args.referenceId = referenceId
4642 
    args.isRefund = isRefund
4600 varun.gupt 4643 
    args.write(self._oprot)
4644 
    self._oprot.writeMessageEnd()
4645 
    self._oprot.trans.flush()
4646 
 
5189 varun.gupt 4647 
  def recv_getSettlementForReferenceId(self, ):
4600 varun.gupt 4648 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4649 
    if mtype == TMessageType.EXCEPTION:
4650 
      x = TApplicationException()
4651 
      x.read(self._iprot)
4652 
      self._iprot.readMessageEnd()
4653 
      raise x
5189 varun.gupt 4654 
    result = getSettlementForReferenceId_result()
4600 varun.gupt 4655 
    result.read(self._iprot)
4656 
    self._iprot.readMessageEnd()
4657 
    if result.success is not None:
4658 
      return result.success
4659 
    if result.ex is not None:
4660 
      raise result.ex
5189 varun.gupt 4661 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForReferenceId failed: unknown result");
4600 varun.gupt 4662 
 
4663 
  def getEBSSettlementSummaries(self, ):
4664 
    self.send_getEBSSettlementSummaries()
4665 
    return self.recv_getEBSSettlementSummaries()
4666 
 
4667 
  def send_getEBSSettlementSummaries(self, ):
4668 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4669 
    args = getEBSSettlementSummaries_args()
4670 
    args.write(self._oprot)
4671 
    self._oprot.writeMessageEnd()
4672 
    self._oprot.trans.flush()
4673 
 
4674 
  def recv_getEBSSettlementSummaries(self, ):
4675 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4676 
    if mtype == TMessageType.EXCEPTION:
4677 
      x = TApplicationException()
4678 
      x.read(self._iprot)
4679 
      self._iprot.readMessageEnd()
4680 
      raise x
4681 
    result = getEBSSettlementSummaries_result()
4682 
    result.read(self._iprot)
4683 
    self._iprot.readMessageEnd()
4684 
    if result.success is not None:
4685 
      return result.success
4686 
    if result.ex is not None:
4687 
      raise result.ex
4688 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4689 
 
4690 
  def markEBSSettlementUploaded(self, settlementId):
4691 
    """
4692 
    Parameters:
4693 
     - settlementId
4694 
    """
4695 
    self.send_markEBSSettlementUploaded(settlementId)
4696 
    self.recv_markEBSSettlementUploaded()
4697 
 
4698 
  def send_markEBSSettlementUploaded(self, settlementId):
4699 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4700 
    args = markEBSSettlementUploaded_args()
4701 
    args.settlementId = settlementId
4702 
    args.write(self._oprot)
4703 
    self._oprot.writeMessageEnd()
4704 
    self._oprot.trans.flush()
4705 
 
4706 
  def recv_markEBSSettlementUploaded(self, ):
4707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4708 
    if mtype == TMessageType.EXCEPTION:
4709 
      x = TApplicationException()
4710 
      x.read(self._iprot)
4711 
      self._iprot.readMessageEnd()
4712 
      raise x
4713 
    result = markEBSSettlementUploaded_result()
4714 
    result.read(self._iprot)
4715 
    self._iprot.readMessageEnd()
4716 
    if result.ex is not None:
4717 
      raise result.ex
4718 
    return
4719 
 
4720 
  def getEBSSettlementDate(self, settlementId):
4721 
    """
4722 
    Parameters:
4723 
     - settlementId
4724 
    """
4725 
    self.send_getEBSSettlementDate(settlementId)
4726 
    return self.recv_getEBSSettlementDate()
4727 
 
4728 
  def send_getEBSSettlementDate(self, settlementId):
4729 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4730 
    args = getEBSSettlementDate_args()
4731 
    args.settlementId = settlementId
4732 
    args.write(self._oprot)
4733 
    self._oprot.writeMessageEnd()
4734 
    self._oprot.trans.flush()
4735 
 
4736 
  def recv_getEBSSettlementDate(self, ):
4737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4738 
    if mtype == TMessageType.EXCEPTION:
4739 
      x = TApplicationException()
4740 
      x.read(self._iprot)
4741 
      self._iprot.readMessageEnd()
4742 
      raise x
4743 
    result = getEBSSettlementDate_result()
4744 
    result.read(self._iprot)
4745 
    self._iprot.readMessageEnd()
4746 
    if result.success is not None:
4747 
      return result.success
4748 
    if result.ex is not None:
4749 
      raise result.ex
4750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4751 
 
4715 varun.gupt 4752 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4753 
    """
4754 
    Parameters:
4755 
     - settlementDateFrom
4756 
     - settlementDateTo
4757 
     - isRefund
4758 
    """
4759 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4760 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4761 
 
4715 varun.gupt 4762 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4763 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4764 
    args = getSettlementsByDate_args()
4765 
    args.settlementDateFrom = settlementDateFrom
4766 
    args.settlementDateTo = settlementDateTo
4767 
    args.isRefund = isRefund
4768 
    args.write(self._oprot)
4769 
    self._oprot.writeMessageEnd()
4770 
    self._oprot.trans.flush()
4771 
 
4772 
  def recv_getSettlementsByDate(self, ):
4773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4774 
    if mtype == TMessageType.EXCEPTION:
4775 
      x = TApplicationException()
4776 
      x.read(self._iprot)
4777 
      self._iprot.readMessageEnd()
4778 
      raise x
4779 
    result = getSettlementsByDate_result()
4780 
    result.read(self._iprot)
4781 
    self._iprot.readMessageEnd()
4782 
    if result.success is not None:
4783 
      return result.success
4784 
    if result.ex is not None:
4785 
      raise result.ex
4786 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4787 
 
4788 
  def getReshippedOrderIds(self, orderIds):
4789 
    """
4790 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4791 
 
4792 
    Parameters:
4793 
     - orderIds
4794 
    """
4795 
    self.send_getReshippedOrderIds(orderIds)
4796 
    return self.recv_getReshippedOrderIds()
4797 
 
4798 
  def send_getReshippedOrderIds(self, orderIds):
4799 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4800 
    args = getReshippedOrderIds_args()
4801 
    args.orderIds = orderIds
4802 
    args.write(self._oprot)
4803 
    self._oprot.writeMessageEnd()
4804 
    self._oprot.trans.flush()
4805 
 
4806 
  def recv_getReshippedOrderIds(self, ):
4807 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4808 
    if mtype == TMessageType.EXCEPTION:
4809 
      x = TApplicationException()
4810 
      x.read(self._iprot)
4811 
      self._iprot.readMessageEnd()
4812 
      raise x
4813 
    result = getReshippedOrderIds_result()
4814 
    result.read(self._iprot)
4815 
    self._iprot.readMessageEnd()
4816 
    if result.success is not None:
4817 
      return result.success
4818 
    if result.ex is not None:
4819 
      raise result.ex
4820 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4821 
 
5348 anupam.sin 4822 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4823 
    """
4824 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
4825 
    the quantities for which the PO is raised.
4826 
 
4827 
    Parameters:
4828 
     - itemIdQuantityMap
4829 
     - purchaseOrderId
4830 
     - warehouseId
4831 
    """
4832 
    self.send_updateOrdersAsPORaised(itemIdQuantityMap, purchaseOrderId, warehouseId)
4833 
    self.recv_updateOrdersAsPORaised()
4834 
 
4835 
  def send_updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4836 
    self._oprot.writeMessageBegin('updateOrdersAsPORaised', TMessageType.CALL, self._seqid)
4837 
    args = updateOrdersAsPORaised_args()
4838 
    args.itemIdQuantityMap = itemIdQuantityMap
4839 
    args.purchaseOrderId = purchaseOrderId
4840 
    args.warehouseId = warehouseId
4841 
    args.write(self._oprot)
4842 
    self._oprot.writeMessageEnd()
4843 
    self._oprot.trans.flush()
4844 
 
4845 
  def recv_updateOrdersAsPORaised(self, ):
4846 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4847 
    if mtype == TMessageType.EXCEPTION:
4848 
      x = TApplicationException()
4849 
      x.read(self._iprot)
4850 
      self._iprot.readMessageEnd()
4851 
      raise x
4852 
    result = updateOrdersAsPORaised_result()
4853 
    result.read(self._iprot)
4854 
    self._iprot.readMessageEnd()
4855 
    if result.ex is not None:
4856 
      raise result.ex
4857 
    return
4858 
 
4875 varun.gupt 4859 
  def getOrdersWhereVendorNotPaid(self, vendorId):
4860 
    """
4861 
    Parameters:
4862 
     - vendorId
4863 
    """
4864 
    self.send_getOrdersWhereVendorNotPaid(vendorId)
4865 
    return self.recv_getOrdersWhereVendorNotPaid()
4757 mandeep.dh 4866 
 
4875 varun.gupt 4867 
  def send_getOrdersWhereVendorNotPaid(self, vendorId):
4868 
    self._oprot.writeMessageBegin('getOrdersWhereVendorNotPaid', TMessageType.CALL, self._seqid)
4869 
    args = getOrdersWhereVendorNotPaid_args()
4870 
    args.vendorId = vendorId
4871 
    args.write(self._oprot)
4872 
    self._oprot.writeMessageEnd()
4873 
    self._oprot.trans.flush()
4874 
 
4875 
  def recv_getOrdersWhereVendorNotPaid(self, ):
4876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4877 
    if mtype == TMessageType.EXCEPTION:
4878 
      x = TApplicationException()
4879 
      x.read(self._iprot)
4880 
      self._iprot.readMessageEnd()
4881 
      raise x
4882 
    result = getOrdersWhereVendorNotPaid_result()
4883 
    result.read(self._iprot)
4884 
    self._iprot.readMessageEnd()
4885 
    if result.success is not None:
4886 
      return result.success
4887 
    if result.ex is not None:
4888 
      raise result.ex
4889 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersWhereVendorNotPaid failed: unknown result");
4890 
 
5031 varun.gupt 4891 
  def getStatusDistributionOfOrders(self, startDate, endDate):
4892 
    """
4893 
    Parameters:
4894 
     - startDate
4895 
     - endDate
4896 
    """
4897 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
4898 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 4899 
 
5031 varun.gupt 4900 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
4901 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
4902 
    args = getStatusDistributionOfOrders_args()
4903 
    args.startDate = startDate
4904 
    args.endDate = endDate
4905 
    args.write(self._oprot)
4906 
    self._oprot.writeMessageEnd()
4907 
    self._oprot.trans.flush()
4908 
 
4909 
  def recv_getStatusDistributionOfOrders(self, ):
4910 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4911 
    if mtype == TMessageType.EXCEPTION:
4912 
      x = TApplicationException()
4913 
      x.read(self._iprot)
4914 
      self._iprot.readMessageEnd()
4915 
      raise x
4916 
    result = getStatusDistributionOfOrders_result()
4917 
    result.read(self._iprot)
4918 
    self._iprot.readMessageEnd()
4919 
    if result.success is not None:
4920 
      return result.success
4921 
    if result.ex is not None:
4922 
      raise result.ex
4923 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
4924 
 
5067 varun.gupt 4925 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
4926 
    """
4927 
    Parameters:
4928 
     - status
4929 
     - startDatetime
4930 
     - endDatetime
4931 
    """
4932 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
4933 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 4934 
 
5067 varun.gupt 4935 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
4936 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
4937 
    args = getOrderIdsForStatus_args()
4938 
    args.status = status
4939 
    args.startDatetime = startDatetime
4940 
    args.endDatetime = endDatetime
4941 
    args.write(self._oprot)
4942 
    self._oprot.writeMessageEnd()
4943 
    self._oprot.trans.flush()
4944 
 
4945 
  def recv_getOrderIdsForStatus(self, ):
4946 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4947 
    if mtype == TMessageType.EXCEPTION:
4948 
      x = TApplicationException()
4949 
      x.read(self._iprot)
4950 
      self._iprot.readMessageEnd()
4951 
      raise x
4952 
    result = getOrderIdsForStatus_result()
4953 
    result.read(self._iprot)
4954 
    self._iprot.readMessageEnd()
4955 
    if result.success is not None:
4956 
      return result.success
4957 
    if result.ex is not None:
4958 
      raise result.ex
4959 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
4960 
 
5348 anupam.sin 4961 
  def updateCODAgent(self, agent, orderId):
4962 
    """
4963 
    Updates the agent who handled the COD verification call
4964 
 
4965 
    Parameters:
4966 
     - agent
4967 
     - orderId
4968 
    """
4969 
    self.send_updateCODAgent(agent, orderId)
4970 
    self.recv_updateCODAgent()
4971 
 
4972 
  def send_updateCODAgent(self, agent, orderId):
4973 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
4974 
    args = updateCODAgent_args()
4975 
    args.agent = agent
4976 
    args.orderId = orderId
4977 
    args.write(self._oprot)
4978 
    self._oprot.writeMessageEnd()
4979 
    self._oprot.trans.flush()
4980 
 
4981 
  def recv_updateCODAgent(self, ):
4982 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4983 
    if mtype == TMessageType.EXCEPTION:
4984 
      x = TApplicationException()
4985 
      x.read(self._iprot)
4986 
      self._iprot.readMessageEnd()
4987 
      raise x
4988 
    result = updateCODAgent_result()
4989 
    result.read(self._iprot)
4990 
    self._iprot.readMessageEnd()
4991 
    if result.ex is not None:
4992 
      raise result.ex
4993 
    return
4994 
 
5099 varun.gupt 4995 
  def updateOrderAsPaidToVendor(self, orderId):
4996 
    """
4997 
    Parameters:
4998 
     - orderId
4999 
    """
5000 
    self.send_updateOrderAsPaidToVendor(orderId)
5001 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5002 
 
5099 varun.gupt 5003 
  def send_updateOrderAsPaidToVendor(self, orderId):
5004 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5005 
    args = updateOrderAsPaidToVendor_args()
5006 
    args.orderId = orderId
5007 
    args.write(self._oprot)
5008 
    self._oprot.writeMessageEnd()
5009 
    self._oprot.trans.flush()
5010 
 
5011 
  def recv_updateOrderAsPaidToVendor(self, ):
5012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5013 
    if mtype == TMessageType.EXCEPTION:
5014 
      x = TApplicationException()
5015 
      x.read(self._iprot)
5016 
      self._iprot.readMessageEnd()
5017 
      raise x
5018 
    result = updateOrderAsPaidToVendor_result()
5019 
    result.read(self._iprot)
5020 
    self._iprot.readMessageEnd()
5021 
    if result.ex is not None:
5022 
      raise result.ex
5023 
    return
5024 
 
5208 varun.gupt 5025 
  def getRefundedOrdersMarkedPaid(self, ):
5026 
    self.send_getRefundedOrdersMarkedPaid()
5027 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5028 
 
5208 varun.gupt 5029 
  def send_getRefundedOrdersMarkedPaid(self, ):
5030 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5031 
    args = getRefundedOrdersMarkedPaid_args()
5032 
    args.write(self._oprot)
5033 
    self._oprot.writeMessageEnd()
5034 
    self._oprot.trans.flush()
5035 
 
5036 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5037 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5038 
    if mtype == TMessageType.EXCEPTION:
5039 
      x = TApplicationException()
5040 
      x.read(self._iprot)
5041 
      self._iprot.readMessageEnd()
5042 
      raise x
5043 
    result = getRefundedOrdersMarkedPaid_result()
5044 
    result.read(self._iprot)
5045 
    self._iprot.readMessageEnd()
5046 
    if result.success is not None:
5047 
      return result.success
5048 
    if result.ex is not None:
5049 
      raise result.ex
5050 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5051 
 
5052 
 
3376 rajveer 5053 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 5054 
  def __init__(self, handler):
3376 rajveer 5055 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 5056 
    self._processMap["createTransaction"] = Processor.process_createTransaction
5057 
    self._processMap["getTransaction"] = Processor.process_getTransaction
5058 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 5059 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 5060 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
5061 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 5062 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 5063 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 5064 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
5065 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 5066 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 5067 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 5068 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
5069 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 5070 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
5071 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
5072 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
5073 
    self._processMap["createOrder"] = Processor.process_createOrder
5074 
    self._processMap["getOrder"] = Processor.process_getOrder
5075 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 5076 
    self._processMap["getOrderList"] = Processor.process_getOrderList
1528 ankur.sing 5077 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 5078 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 5079 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 5080 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 5081 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
5082 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
5083 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
5084 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 5085 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 5086 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 5087 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
5088 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
5089 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 5090 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 5091 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 5092 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 5093 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 5094 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 5095 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
5096 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 5097 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 5098 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
5099 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
5100 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
5101 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
5102 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 5103 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 5104 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 5105 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 5106 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 5107 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
5108 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 5109 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
5110 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 5111 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
5112 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 5113 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 5114 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 5115 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 5116 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 5117 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 5118 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 5119 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 5120 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
5121 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 5122 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 5123 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 5124 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 5125 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 5126 
    self._processMap["changeItem"] = Processor.process_changeItem
5127 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 5128 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 5129 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 5130 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
5131 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 5132 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 5133 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 5134 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
5135 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
5136 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 5137 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 5138 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 5139 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 5140 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 5141 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
5142 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
5143 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 5144 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 5145 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 5146 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 5147 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 5148 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 5149 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 5150 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 5151 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
5152 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
5153 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5189 varun.gupt 5154 
    self._processMap["getSettlementForReferenceId"] = Processor.process_getSettlementForReferenceId
4600 varun.gupt 5155 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
5156 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
5157 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 5158 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
5159 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5348 anupam.sin 5160 
    self._processMap["updateOrdersAsPORaised"] = Processor.process_updateOrdersAsPORaised
4875 varun.gupt 5161 
    self._processMap["getOrdersWhereVendorNotPaid"] = Processor.process_getOrdersWhereVendorNotPaid
5031 varun.gupt 5162 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 5163 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 5164 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 5165 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5208 varun.gupt 5166 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
94 ashish 5167 
 
5168 
  def process(self, iprot, oprot):
5169 
    (name, type, seqid) = iprot.readMessageBegin()
5170 
    if name not in self._processMap:
5171 
      iprot.skip(TType.STRUCT)
5172 
      iprot.readMessageEnd()
5173 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5174 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5175 
      x.write(oprot)
5176 
      oprot.writeMessageEnd()
5177 
      oprot.trans.flush()
5178 
      return
5179 
    else:
5180 
      self._processMap[name](self, seqid, iprot, oprot)
5181 
    return True
5182 
 
5183 
  def process_createTransaction(self, seqid, iprot, oprot):
5184 
    args = createTransaction_args()
5185 
    args.read(iprot)
5186 
    iprot.readMessageEnd()
5187 
    result = createTransaction_result()
5188 
    try:
132 ashish 5189 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 5190 
    except TransactionServiceException, ex:
5191 
      result.ex = ex
5192 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
5193 
    result.write(oprot)
5194 
    oprot.writeMessageEnd()
5195 
    oprot.trans.flush()
5196 
 
5197 
  def process_getTransaction(self, seqid, iprot, oprot):
5198 
    args = getTransaction_args()
5199 
    args.read(iprot)
5200 
    iprot.readMessageEnd()
5201 
    result = getTransaction_result()
5202 
    try:
5203 
      result.success = self._handler.getTransaction(args.id)
5204 
    except TransactionServiceException, ex:
5205 
      result.ex = ex
5206 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
5207 
    result.write(oprot)
5208 
    oprot.writeMessageEnd()
5209 
    oprot.trans.flush()
5210 
 
5211 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
5212 
    args = getTransactionsForCustomer_args()
5213 
    args.read(iprot)
5214 
    iprot.readMessageEnd()
5215 
    result = getTransactionsForCustomer_result()
5216 
    try:
5217 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
5218 
    except TransactionServiceException, ex:
5219 
      result.ex = ex
5220 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
5221 
    result.write(oprot)
5222 
    oprot.writeMessageEnd()
5223 
    oprot.trans.flush()
5224 
 
132 ashish 5225 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
5226 
    args = getTransactionsForShoppingCartId_args()
5227 
    args.read(iprot)
5228 
    iprot.readMessageEnd()
5229 
    result = getTransactionsForShoppingCartId_result()
5230 
    try:
5231 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
5232 
    except TransactionServiceException, ex:
5233 
      result.ex = ex
5234 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
5235 
    result.write(oprot)
5236 
    oprot.writeMessageEnd()
5237 
    oprot.trans.flush()
5238 
 
94 ashish 5239 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
5240 
    args = getTransactionStatus_args()
5241 
    args.read(iprot)
5242 
    iprot.readMessageEnd()
5243 
    result = getTransactionStatus_result()
5244 
    try:
5245 
      result.success = self._handler.getTransactionStatus(args.transactionId)
5246 
    except TransactionServiceException, ex:
5247 
      result.ex = ex
5248 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
5249 
    result.write(oprot)
5250 
    oprot.writeMessageEnd()
5251 
    oprot.trans.flush()
5252 
 
5253 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
5254 
    args = changeTransactionStatus_args()
5255 
    args.read(iprot)
5256 
    iprot.readMessageEnd()
5257 
    result = changeTransactionStatus_result()
5258 
    try:
5259 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
5260 
    except TransactionServiceException, ex:
5261 
      result.ex = ex
5262 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
5263 
    result.write(oprot)
5264 
    oprot.writeMessageEnd()
5265 
    oprot.trans.flush()
5266 
 
1398 varun.gupt 5267 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
5268 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 5269 
    args.read(iprot)
5270 
    iprot.readMessageEnd()
1398 varun.gupt 5271 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 5272 
    try:
1398 varun.gupt 5273 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 5274 
    except TransactionServiceException, ex:
5275 
      result.ex = ex
1398 varun.gupt 5276 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 5277 
    result.write(oprot)
5278 
    oprot.writeMessageEnd()
5279 
    oprot.trans.flush()
5280 
 
483 rajveer 5281 
  def process_getAllOrders(self, seqid, iprot, oprot):
5282 
    args = getAllOrders_args()
94 ashish 5283 
    args.read(iprot)
5284 
    iprot.readMessageEnd()
483 rajveer 5285 
    result = getAllOrders_result()
94 ashish 5286 
    try:
4801 anupam.sin 5287 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 5288 
    except TransactionServiceException, ex:
5289 
      result.ex = ex
483 rajveer 5290 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 5291 
    result.write(oprot)
5292 
    oprot.writeMessageEnd()
5293 
    oprot.trans.flush()
5294 
 
4133 chandransh 5295 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
5296 
    args = getOrdersInBatch_args()
5297 
    args.read(iprot)
5298 
    iprot.readMessageEnd()
5299 
    result = getOrdersInBatch_result()
5300 
    try:
5301 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
5302 
    except TransactionServiceException, ex:
5303 
      result.ex = ex
5304 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
5305 
    result.write(oprot)
5306 
    oprot.writeMessageEnd()
5307 
    oprot.trans.flush()
5308 
 
5309 
  def process_getOrderCount(self, seqid, iprot, oprot):
5310 
    args = getOrderCount_args()
5311 
    args.read(iprot)
5312 
    iprot.readMessageEnd()
5313 
    result = getOrderCount_result()
5314 
    try:
5315 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
5316 
    except TransactionServiceException, ex:
5317 
      result.ex = ex
5318 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
5319 
    result.write(oprot)
5320 
    oprot.writeMessageEnd()
5321 
    oprot.trans.flush()
5322 
 
999 varun.gupt 5323 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
5324 
    args = getOrdersByBillingDate_args()
5325 
    args.read(iprot)
5326 
    iprot.readMessageEnd()
5327 
    result = getOrdersByBillingDate_result()
5328 
    try:
5329 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
5330 
    except TransactionServiceException, ex:
5331 
      result.ex = ex
5332 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
5333 
    result.write(oprot)
5334 
    oprot.writeMessageEnd()
5335 
    oprot.trans.flush()
5336 
 
3427 chandransh 5337 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
5338 
    args = getOrdersByShippingDate_args()
5339 
    args.read(iprot)
5340 
    iprot.readMessageEnd()
5341 
    result = getOrdersByShippingDate_result()
5342 
    try:
3451 chandransh 5343 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 5344 
    except TransactionServiceException, ex:
5345 
      result.ex = ex
5346 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
5347 
    result.write(oprot)
5348 
    oprot.writeMessageEnd()
5349 
    oprot.trans.flush()
5350 
 
1382 varun.gupt 5351 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
5352 
    args = getReturnableOrdersForCustomer_args()
5353 
    args.read(iprot)
5354 
    iprot.readMessageEnd()
5355 
    result = getReturnableOrdersForCustomer_result()
5356 
    try:
5357 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
5358 
    except TransactionServiceException, ex:
5359 
      result.ex = ex
5360 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
5361 
    result.write(oprot)
5362 
    oprot.writeMessageEnd()
5363 
    oprot.trans.flush()
5364 
 
5365 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
5366 
    args = getCancellableOrdersForCustomer_args()
5367 
    args.read(iprot)
5368 
    iprot.readMessageEnd()
5369 
    result = getCancellableOrdersForCustomer_result()
5370 
    try:
5371 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
5372 
    except TransactionServiceException, ex:
5373 
      result.ex = ex
5374 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
5375 
    result.write(oprot)
5376 
    oprot.writeMessageEnd()
5377 
    oprot.trans.flush()
5378 
 
483 rajveer 5379 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
5380 
    args = changeOrderStatus_args()
94 ashish 5381 
    args.read(iprot)
5382 
    iprot.readMessageEnd()
483 rajveer 5383 
    result = changeOrderStatus_result()
94 ashish 5384 
    try:
483 rajveer 5385 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 5386 
    except TransactionServiceException, ex:
5387 
      result.ex = ex
483 rajveer 5388 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 5389 
    result.write(oprot)
5390 
    oprot.writeMessageEnd()
5391 
    oprot.trans.flush()
5392 
 
483 rajveer 5393 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
5394 
    args = getOrdersForTransaction_args()
94 ashish 5395 
    args.read(iprot)
5396 
    iprot.readMessageEnd()
483 rajveer 5397 
    result = getOrdersForTransaction_result()
94 ashish 5398 
    try:
1528 ankur.sing 5399 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 5400 
    except TransactionServiceException, ex:
5401 
      result.ex = ex
483 rajveer 5402 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 5403 
    result.write(oprot)
5404 
    oprot.writeMessageEnd()
5405 
    oprot.trans.flush()
5406 
 
483 rajveer 5407 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
5408 
    args = getOrdersForCustomer_args()
94 ashish 5409 
    args.read(iprot)
5410 
    iprot.readMessageEnd()
483 rajveer 5411 
    result = getOrdersForCustomer_result()
94 ashish 5412 
    try:
3014 chandransh 5413 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 5414 
    except TransactionServiceException, ex:
5415 
      result.ex = ex
483 rajveer 5416 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 5417 
    result.write(oprot)
5418 
    oprot.writeMessageEnd()
5419 
    oprot.trans.flush()
5420 
 
483 rajveer 5421 
  def process_createOrder(self, seqid, iprot, oprot):
5422 
    args = createOrder_args()
94 ashish 5423 
    args.read(iprot)
5424 
    iprot.readMessageEnd()
483 rajveer 5425 
    result = createOrder_result()
94 ashish 5426 
    try:
483 rajveer 5427 
      result.success = self._handler.createOrder(args.order)
94 ashish 5428 
    except TransactionServiceException, ex:
5429 
      result.ex = ex
483 rajveer 5430 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 5431 
    result.write(oprot)
5432 
    oprot.writeMessageEnd()
5433 
    oprot.trans.flush()
5434 
 
483 rajveer 5435 
  def process_getOrder(self, seqid, iprot, oprot):
5436 
    args = getOrder_args()
94 ashish 5437 
    args.read(iprot)
5438 
    iprot.readMessageEnd()
483 rajveer 5439 
    result = getOrder_result()
94 ashish 5440 
    try:
483 rajveer 5441 
      result.success = self._handler.getOrder(args.id)
94 ashish 5442 
    except TransactionServiceException, ex:
5443 
      result.ex = ex
483 rajveer 5444 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 5445 
    result.write(oprot)
5446 
    oprot.writeMessageEnd()
5447 
    oprot.trans.flush()
5448 
 
483 rajveer 5449 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
5450 
    args = getLineItemsForOrder_args()
94 ashish 5451 
    args.read(iprot)
5452 
    iprot.readMessageEnd()
483 rajveer 5453 
    result = getLineItemsForOrder_result()
94 ashish 5454 
    try:
483 rajveer 5455 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 5456 
    except TransactionServiceException, ex:
5457 
      result.ex = ex
483 rajveer 5458 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 5459 
    result.write(oprot)
5460 
    oprot.writeMessageEnd()
5461 
    oprot.trans.flush()
5462 
 
4999 phani.kuma 5463 
  def process_getOrderList(self, seqid, iprot, oprot):
5464 
    args = getOrderList_args()
5465 
    args.read(iprot)
5466 
    iprot.readMessageEnd()
5467 
    result = getOrderList_result()
5468 
    result.success = self._handler.getOrderList(args.order_ids)
5469 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
5470 
    result.write(oprot)
5471 
    oprot.writeMessageEnd()
5472 
    oprot.trans.flush()
5473 
 
1528 ankur.sing 5474 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
5475 
    args = getOrderForCustomer_args()
5476 
    args.read(iprot)
5477 
    iprot.readMessageEnd()
5478 
    result = getOrderForCustomer_result()
5479 
    try:
5480 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
5481 
    except TransactionServiceException, ex:
5482 
      result.ex = ex
5483 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
5484 
    result.write(oprot)
5485 
    oprot.writeMessageEnd()
5486 
    oprot.trans.flush()
5487 
 
3064 chandransh 5488 
  def process_getAlerts(self, seqid, iprot, oprot):
5489 
    args = getAlerts_args()
5490 
    args.read(iprot)
5491 
    iprot.readMessageEnd()
5492 
    result = getAlerts_result()
4444 rajveer 5493 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 5494 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
5495 
    result.write(oprot)
5496 
    oprot.writeMessageEnd()
5497 
    oprot.trans.flush()
5498 
 
4394 rajveer 5499 
  def process_addAlert(self, seqid, iprot, oprot):
5500 
    args = addAlert_args()
3064 chandransh 5501 
    args.read(iprot)
5502 
    iprot.readMessageEnd()
4394 rajveer 5503 
    result = addAlert_result()
4444 rajveer 5504 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 5505 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 5506 
    result.write(oprot)
5507 
    oprot.writeMessageEnd()
5508 
    oprot.trans.flush()
5509 
 
4444 rajveer 5510 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
5511 
    args = markAlertsAsSeen_args()
5512 
    args.read(iprot)
5513 
    iprot.readMessageEnd()
5514 
    result = markAlertsAsSeen_result()
5515 
    self._handler.markAlertsAsSeen(args.warehouseId)
5516 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
5517 
    result.write(oprot)
5518 
    oprot.writeMessageEnd()
5519 
    oprot.trans.flush()
5520 
 
3064 chandransh 5521 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
5522 
    args = getValidOrderCount_args()
5523 
    args.read(iprot)
5524 
    iprot.readMessageEnd()
5525 
    result = getValidOrderCount_result()
5526 
    result.success = self._handler.getValidOrderCount()
5527 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
5528 
    result.write(oprot)
5529 
    oprot.writeMessageEnd()
5530 
    oprot.trans.flush()
5531 
 
5532 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
5533 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
5534 
    args.read(iprot)
5535 
    iprot.readMessageEnd()
5536 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
5537 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
5538 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
5539 
    result.write(oprot)
5540 
    oprot.writeMessageEnd()
5541 
    oprot.trans.flush()
5542 
 
5543 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
5544 
    args = getValidOrdersAmountRange_args()
5545 
    args.read(iprot)
5546 
    iprot.readMessageEnd()
5547 
    result = getValidOrdersAmountRange_result()
5548 
    result.success = self._handler.getValidOrdersAmountRange()
5549 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
5550 
    result.write(oprot)
5551 
    oprot.writeMessageEnd()
5552 
    oprot.trans.flush()
5553 
 
5554 
  def process_getValidOrders(self, seqid, iprot, oprot):
5555 
    args = getValidOrders_args()
5556 
    args.read(iprot)
5557 
    iprot.readMessageEnd()
5558 
    result = getValidOrders_result()
5559 
    result.success = self._handler.getValidOrders(args.limit)
5560 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
5561 
    result.write(oprot)
5562 
    oprot.writeMessageEnd()
5563 
    oprot.trans.flush()
5564 
 
1220 chandransh 5565 
  def process_batchOrders(self, seqid, iprot, oprot):
5566 
    args = batchOrders_args()
5567 
    args.read(iprot)
5568 
    iprot.readMessageEnd()
5569 
    result = batchOrders_result()
5570 
    try:
5571 
      result.success = self._handler.batchOrders(args.warehouseId)
5572 
    except TransactionServiceException, ex:
5573 
      result.ex = ex
5574 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
5575 
    result.write(oprot)
5576 
    oprot.writeMessageEnd()
5577 
    oprot.trans.flush()
5578 
 
1208 chandransh 5579 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
5580 
    args = markOrderAsOutOfStock_args()
5581 
    args.read(iprot)
5582 
    iprot.readMessageEnd()
5583 
    result = markOrderAsOutOfStock_result()
5584 
    try:
5585 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
5586 
    except TransactionServiceException, ex:
5587 
      result.ex = ex
5588 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
5589 
    result.write(oprot)
5590 
    oprot.writeMessageEnd()
5591 
    oprot.trans.flush()
5592 
 
3064 chandransh 5593 
  def process_verifyOrder(self, seqid, iprot, oprot):
5594 
    args = verifyOrder_args()
759 chandransh 5595 
    args.read(iprot)
5596 
    iprot.readMessageEnd()
3064 chandransh 5597 
    result = verifyOrder_result()
759 chandransh 5598 
    try:
3064 chandransh 5599 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 5600 
    except TransactionServiceException, ex:
5601 
      result.ex = ex
3064 chandransh 5602 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 5603 
    result.write(oprot)
5604 
    oprot.writeMessageEnd()
5605 
    oprot.trans.flush()
5606 
 
3064 chandransh 5607 
  def process_acceptOrder(self, seqid, iprot, oprot):
5608 
    args = acceptOrder_args()
1113 chandransh 5609 
    args.read(iprot)
5610 
    iprot.readMessageEnd()
3064 chandransh 5611 
    result = acceptOrder_result()
1113 chandransh 5612 
    try:
3064 chandransh 5613 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 5614 
    except TransactionServiceException, ex:
5615 
      result.ex = ex
3064 chandransh 5616 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 5617 
    result.write(oprot)
5618 
    oprot.writeMessageEnd()
5619 
    oprot.trans.flush()
5620 
 
3064 chandransh 5621 
  def process_addBillingDetails(self, seqid, iprot, oprot):
5622 
    args = addBillingDetails_args()
1135 chandransh 5623 
    args.read(iprot)
5624 
    iprot.readMessageEnd()
3064 chandransh 5625 
    result = addBillingDetails_result()
1135 chandransh 5626 
    try:
5110 mandeep.dh 5627 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.serialNumber, args.itemNumber, args.billed_by, args.jacketNumber, args.billingType, args.fulfilmentWarehouseId, args.authorize)
1135 chandransh 5628 
    except TransactionServiceException, ex:
5629 
      result.ex = ex
3064 chandransh 5630 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 5631 
    result.write(oprot)
5632 
    oprot.writeMessageEnd()
5633 
    oprot.trans.flush()
5634 
 
4579 rajveer 5635 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
5636 
    args = addInvoiceNumber_args()
5637 
    args.read(iprot)
5638 
    iprot.readMessageEnd()
5639 
    result = addInvoiceNumber_result()
5640 
    try:
4763 rajveer 5641 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 5642 
    except TransactionServiceException, ex:
5643 
      result.ex = ex
5644 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
5645 
    result.write(oprot)
5646 
    oprot.writeMessageEnd()
5647 
    oprot.trans.flush()
5648 
 
4410 rajveer 5649 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5650 
    args = markOrdersAsShippedFromWarehouse_args()
5651 
    args.read(iprot)
5652 
    iprot.readMessageEnd()
5653 
    result = markOrdersAsShippedFromWarehouse_result()
5654 
    try:
4789 rajveer 5655 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 5656 
    except TransactionServiceException, ex:
5657 
      result.ex = ex
5658 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5659 
    result.write(oprot)
5660 
    oprot.writeMessageEnd()
5661 
    oprot.trans.flush()
5662 
 
3064 chandransh 5663 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5664 
    args = markOrdersAsPickedUp_args()
304 ashish 5665 
    args.read(iprot)
5666 
    iprot.readMessageEnd()
3064 chandransh 5667 
    result = markOrdersAsPickedUp_result()
5668 
    try:
4910 phani.kuma 5669 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 5670 
    except TransactionServiceException, ex:
5671 
      result.ex = ex
5672 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5673 
    result.write(oprot)
5674 
    oprot.writeMessageEnd()
5675 
    oprot.trans.flush()
94 ashish 5676 
 
4910 phani.kuma 5677 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
5678 
    args = getOrdersNotPickedUp_args()
5679 
    args.read(iprot)
5680 
    iprot.readMessageEnd()
5681 
    result = getOrdersNotPickedUp_result()
5682 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
5683 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
5684 
    result.write(oprot)
5685 
    oprot.writeMessageEnd()
5686 
    oprot.trans.flush()
5687 
 
3064 chandransh 5688 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5689 
    args = markOrdersAsDelivered_args()
304 ashish 5690 
    args.read(iprot)
5691 
    iprot.readMessageEnd()
3064 chandransh 5692 
    result = markOrdersAsDelivered_result()
5693 
    try:
5694 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5695 
    except TransactionServiceException, ex:
5696 
      result.ex = ex
5697 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5698 
    result.write(oprot)
5699 
    oprot.writeMessageEnd()
5700 
    oprot.trans.flush()
5701 
 
4910 phani.kuma 5702 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
5703 
    args = markAsRTOrders_args()
1596 ankur.sing 5704 
    args.read(iprot)
5705 
    iprot.readMessageEnd()
4910 phani.kuma 5706 
    result = markAsRTOrders_result()
3064 chandransh 5707 
    try:
4910 phani.kuma 5708 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 5709 
    except TransactionServiceException, ex:
5710 
      result.ex = ex
4910 phani.kuma 5711 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 5712 
    result.write(oprot)
5713 
    oprot.writeMessageEnd()
5714 
    oprot.trans.flush()
304 ashish 5715 
 
4910 phani.kuma 5716 
  def process_getRTOrders(self, seqid, iprot, oprot):
5717 
    args = getRTOrders_args()
5718 
    args.read(iprot)
5719 
    iprot.readMessageEnd()
5720 
    result = getRTOrders_result()
5721 
    result.success = self._handler.getRTOrders(args.providerId)
5722 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
5723 
    result.write(oprot)
5724 
    oprot.writeMessageEnd()
5725 
    oprot.trans.flush()
5726 
 
3064 chandransh 5727 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5728 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5729 
    args.read(iprot)
5730 
    iprot.readMessageEnd()
3064 chandransh 5731 
    result = updateNonDeliveryReason_result()
5732 
    try:
4910 phani.kuma 5733 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5734 
    except TransactionServiceException, ex:
5735 
      result.ex = ex
5736 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5737 
    result.write(oprot)
5738 
    oprot.writeMessageEnd()
5739 
    oprot.trans.flush()
1596 ankur.sing 5740 
 
4910 phani.kuma 5741 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
5742 
    args = getNonDeliveredOrdersbyCourier_args()
5743 
    args.read(iprot)
5744 
    iprot.readMessageEnd()
5745 
    result = getNonDeliveredOrdersbyCourier_result()
5746 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
5747 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
5748 
    result.write(oprot)
5749 
    oprot.writeMessageEnd()
5750 
    oprot.trans.flush()
5751 
 
5752 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
5753 
    args = markOrdersAsLocalConnected_args()
5754 
    args.read(iprot)
5755 
    iprot.readMessageEnd()
5756 
    result = markOrdersAsLocalConnected_result()
5757 
    try:
5758 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
5759 
    except TransactionServiceException, ex:
5760 
      result.ex = ex
5761 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
5762 
    result.write(oprot)
5763 
    oprot.writeMessageEnd()
5764 
    oprot.trans.flush()
5765 
 
5766 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
5767 
    args = getOrdersNotLocalConnected_args()
5768 
    args.read(iprot)
5769 
    iprot.readMessageEnd()
5770 
    result = getOrdersNotLocalConnected_result()
5771 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
5772 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
5773 
    result.write(oprot)
5774 
    oprot.writeMessageEnd()
5775 
    oprot.trans.flush()
5776 
 
5777 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
5778 
    args = markOrdersAsDestinationCityReached_args()
5779 
    args.read(iprot)
5780 
    iprot.readMessageEnd()
5781 
    result = markOrdersAsDestinationCityReached_result()
5782 
    try:
5783 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
5784 
    except TransactionServiceException, ex:
5785 
      result.ex = ex
5786 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
5787 
    result.write(oprot)
5788 
    oprot.writeMessageEnd()
5789 
    oprot.trans.flush()
5790 
 
5791 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
5792 
    args = markOrdersAsFirstDeliveryAttempted_args()
5793 
    args.read(iprot)
5794 
    iprot.readMessageEnd()
5795 
    result = markOrdersAsFirstDeliveryAttempted_result()
5796 
    try:
5797 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
5798 
    except TransactionServiceException, ex:
5799 
      result.ex = ex
5800 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
5801 
    result.write(oprot)
5802 
    oprot.writeMessageEnd()
5803 
    oprot.trans.flush()
5804 
 
3064 chandransh 5805 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5806 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5807 
    args.read(iprot)
5808 
    iprot.readMessageEnd()
3064 chandransh 5809 
    result = getUndeliveredOrders_result()
5810 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5811 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5812 
    result.write(oprot)
5813 
    oprot.writeMessageEnd()
5814 
    oprot.trans.flush()
5815 
 
4783 phani.kuma 5816 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
5817 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
5818 
    args.read(iprot)
5819 
    iprot.readMessageEnd()
5820 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
5821 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
5822 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
5823 
    result.write(oprot)
5824 
    oprot.writeMessageEnd()
5825 
    oprot.trans.flush()
5826 
 
2536 chandransh 5827 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5828 
    args = toggleDOAFlag_args()
5829 
    args.read(iprot)
5830 
    iprot.readMessageEnd()
5831 
    result = toggleDOAFlag_result()
5832 
    try:
5833 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5834 
    except TransactionServiceException, ex:
5835 
      result.ex = ex
5836 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5837 
    result.write(oprot)
5838 
    oprot.writeMessageEnd()
5839 
    oprot.trans.flush()
1886 ankur.sing 5840 
 
4712 rajveer 5841 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5842 
    args = markOrderAsDelivered_args()
5843 
    args.read(iprot)
5844 
    iprot.readMessageEnd()
5845 
    result = markOrderAsDelivered_result()
5846 
    try:
5847 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5848 
    except TransactionServiceException, ex:
5849 
      result.ex = ex
5850 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5851 
    result.write(oprot)
5852 
    oprot.writeMessageEnd()
5853 
    oprot.trans.flush()
5854 
 
4454 rajveer 5855 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5856 
    args = markOrderDoaRequestReceived_args()
5857 
    args.read(iprot)
5858 
    iprot.readMessageEnd()
5859 
    result = markOrderDoaRequestReceived_result()
5860 
    try:
5861 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5862 
    except TransactionServiceException, ex:
5863 
      result.ex = ex
5864 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5865 
    result.write(oprot)
5866 
    oprot.writeMessageEnd()
5867 
    oprot.trans.flush()
5868 
 
5869 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
5870 
    args = markOrderDoaRequestAuthorized_args()
5871 
    args.read(iprot)
5872 
    iprot.readMessageEnd()
5873 
    result = markOrderDoaRequestAuthorized_result()
5874 
    try:
5875 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
5876 
    except TransactionServiceException, ex:
5877 
      result.ex = ex
5878 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
5879 
    result.write(oprot)
5880 
    oprot.writeMessageEnd()
5881 
    oprot.trans.flush()
5882 
 
4488 rajveer 5883 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5884 
    args = markOrderReturnRequestReceived_args()
5885 
    args.read(iprot)
5886 
    iprot.readMessageEnd()
5887 
    result = markOrderReturnRequestReceived_result()
5888 
    try:
5889 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5890 
    except TransactionServiceException, ex:
5891 
      result.ex = ex
5892 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5893 
    result.write(oprot)
5894 
    oprot.writeMessageEnd()
5895 
    oprot.trans.flush()
5896 
 
5897 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5898 
    args = markOrderReturnRequestAuthorized_args()
5899 
    args.read(iprot)
5900 
    iprot.readMessageEnd()
5901 
    result = markOrderReturnRequestAuthorized_result()
5902 
    try:
5903 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5904 
    except TransactionServiceException, ex:
5905 
      result.ex = ex
5906 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5907 
    result.write(oprot)
5908 
    oprot.writeMessageEnd()
5909 
    oprot.trans.flush()
5910 
 
2536 chandransh 5911 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5912 
    args = requestPickupNumber_args()
5913 
    args.read(iprot)
5914 
    iprot.readMessageEnd()
5915 
    result = requestPickupNumber_result()
5916 
    try:
4579 rajveer 5917 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 5918 
    except TransactionServiceException, ex:
5919 
      result.ex = ex
5920 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
5921 
    result.write(oprot)
5922 
    oprot.writeMessageEnd()
5923 
    oprot.trans.flush()
5924 
 
5925 
  def process_authorizePickup(self, seqid, iprot, oprot):
5926 
    args = authorizePickup_args()
5927 
    args.read(iprot)
5928 
    iprot.readMessageEnd()
5929 
    result = authorizePickup_result()
5930 
    try:
4602 rajveer 5931 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 5932 
    except TransactionServiceException, ex:
5933 
      result.ex = ex
5934 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
5935 
    result.write(oprot)
5936 
    oprot.writeMessageEnd()
5937 
    oprot.trans.flush()
5938 
 
2764 chandransh 5939 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
5940 
    args = markDoasAsPickedUp_args()
5941 
    args.read(iprot)
5942 
    iprot.readMessageEnd()
5943 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 5944 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 5945 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
5946 
    result.write(oprot)
5947 
    oprot.writeMessageEnd()
5948 
    oprot.trans.flush()
5949 
 
4910 phani.kuma 5950 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
5951 
    args = getDoasNotPickedUp_args()
5952 
    args.read(iprot)
5953 
    iprot.readMessageEnd()
5954 
    result = getDoasNotPickedUp_result()
5955 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
5956 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
5957 
    result.write(oprot)
5958 
    oprot.writeMessageEnd()
5959 
    oprot.trans.flush()
5960 
 
4741 phani.kuma 5961 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
5962 
    args = markReturnOrdersAsPickedUp_args()
5963 
    args.read(iprot)
5964 
    iprot.readMessageEnd()
5965 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 5966 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 5967 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
5968 
    result.write(oprot)
5969 
    oprot.writeMessageEnd()
5970 
    oprot.trans.flush()
5971 
 
4910 phani.kuma 5972 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
5973 
    args = getReturnOrdersNotPickedUp_args()
5974 
    args.read(iprot)
5975 
    iprot.readMessageEnd()
5976 
    result = getReturnOrdersNotPickedUp_result()
5977 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
5978 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
5979 
    result.write(oprot)
5980 
    oprot.writeMessageEnd()
5981 
    oprot.trans.flush()
5982 
 
2616 chandransh 5983 
  def process_receiveReturn(self, seqid, iprot, oprot):
5984 
    args = receiveReturn_args()
2591 chandransh 5985 
    args.read(iprot)
5986 
    iprot.readMessageEnd()
2616 chandransh 5987 
    result = receiveReturn_result()
2591 chandransh 5988 
    try:
4479 rajveer 5989 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 5990 
    except TransactionServiceException, ex:
5991 
      result.ex = ex
2616 chandransh 5992 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 5993 
    result.write(oprot)
5994 
    oprot.writeMessageEnd()
5995 
    oprot.trans.flush()
2536 chandransh 5996 
 
2591 chandransh 5997 
  def process_validateDoa(self, seqid, iprot, oprot):
5998 
    args = validateDoa_args()
5999 
    args.read(iprot)
6000 
    iprot.readMessageEnd()
6001 
    result = validateDoa_result()
6002 
    try:
6003 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
6004 
    except TransactionServiceException, ex:
6005 
      result.ex = ex
6006 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
6007 
    result.write(oprot)
6008 
    oprot.writeMessageEnd()
6009 
    oprot.trans.flush()
6010 
 
4495 rajveer 6011 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
6012 
    args = validateReturnProduct_args()
6013 
    args.read(iprot)
6014 
    iprot.readMessageEnd()
6015 
    result = validateReturnProduct_result()
6016 
    try:
6017 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
6018 
    except TransactionServiceException, ex:
6019 
      result.ex = ex
6020 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
6021 
    result.write(oprot)
6022 
    oprot.writeMessageEnd()
6023 
    oprot.trans.flush()
6024 
 
2616 chandransh 6025 
  def process_reshipOrder(self, seqid, iprot, oprot):
6026 
    args = reshipOrder_args()
6027 
    args.read(iprot)
6028 
    iprot.readMessageEnd()
6029 
    result = reshipOrder_result()
6030 
    try:
6031 
      result.success = self._handler.reshipOrder(args.orderId)
6032 
    except TransactionServiceException, ex:
6033 
      result.ex = ex
6034 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
6035 
    result.write(oprot)
6036 
    oprot.writeMessageEnd()
6037 
    oprot.trans.flush()
2591 chandransh 6038 
 
2616 chandransh 6039 
  def process_refundOrder(self, seqid, iprot, oprot):
6040 
    args = refundOrder_args()
6041 
    args.read(iprot)
6042 
    iprot.readMessageEnd()
6043 
    result = refundOrder_result()
6044 
    try:
3226 chandransh 6045 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 6046 
    except TransactionServiceException, ex:
6047 
      result.ex = ex
6048 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
6049 
    result.write(oprot)
6050 
    oprot.writeMessageEnd()
6051 
    oprot.trans.flush()
6052 
 
2690 chandransh 6053 
  def process_getReturnOrders(self, seqid, iprot, oprot):
6054 
    args = getReturnOrders_args()
6055 
    args.read(iprot)
6056 
    iprot.readMessageEnd()
6057 
    result = getReturnOrders_result()
6058 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
6059 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
6060 
    result.write(oprot)
6061 
    oprot.writeMessageEnd()
6062 
    oprot.trans.flush()
2616 chandransh 6063 
 
2700 chandransh 6064 
  def process_getReturnOrder(self, seqid, iprot, oprot):
6065 
    args = getReturnOrder_args()
6066 
    args.read(iprot)
6067 
    iprot.readMessageEnd()
6068 
    result = getReturnOrder_result()
6069 
    try:
6070 
      result.success = self._handler.getReturnOrder(args.id)
6071 
    except TransactionServiceException, ex:
6072 
      result.ex = ex
6073 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
6074 
    result.write(oprot)
6075 
    oprot.writeMessageEnd()
6076 
    oprot.trans.flush()
6077 
 
2690 chandransh 6078 
  def process_processReturn(self, seqid, iprot, oprot):
6079 
    args = processReturn_args()
6080 
    args.read(iprot)
6081 
    iprot.readMessageEnd()
6082 
    result = processReturn_result()
6083 
    try:
6084 
      self._handler.processReturn(args.returnOrderId)
6085 
    except TransactionServiceException, ex:
6086 
      result.ex = ex
6087 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
6088 
    result.write(oprot)
6089 
    oprot.writeMessageEnd()
6090 
    oprot.trans.flush()
6091 
 
3451 chandransh 6092 
  def process_updateWeight(self, seqid, iprot, oprot):
6093 
    args = updateWeight_args()
6094 
    args.read(iprot)
6095 
    iprot.readMessageEnd()
6096 
    result = updateWeight_result()
6097 
    try:
6098 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
6099 
    except TransactionServiceException, ex:
6100 
      result.ex = ex
6101 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
6102 
    result.write(oprot)
6103 
    oprot.writeMessageEnd()
6104 
    oprot.trans.flush()
2819 chandransh 6105 
 
3469 chandransh 6106 
  def process_changeItem(self, seqid, iprot, oprot):
6107 
    args = changeItem_args()
6108 
    args.read(iprot)
6109 
    iprot.readMessageEnd()
6110 
    result = changeItem_result()
6111 
    try:
6112 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
6113 
    except TransactionServiceException, ex:
6114 
      result.ex = ex
6115 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
6116 
    result.write(oprot)
6117 
    oprot.writeMessageEnd()
6118 
    oprot.trans.flush()
3451 chandransh 6119 
 
3469 chandransh 6120 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
6121 
    args = shiftToWarehouse_args()
6122 
    args.read(iprot)
6123 
    iprot.readMessageEnd()
6124 
    result = shiftToWarehouse_result()
6125 
    try:
6126 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
6127 
    except TransactionServiceException, ex:
6128 
      result.ex = ex
6129 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
6130 
    result.write(oprot)
6131 
    oprot.writeMessageEnd()
6132 
    oprot.trans.flush()
6133 
 
3553 chandransh 6134 
  def process_addDelayReason(self, seqid, iprot, oprot):
6135 
    args = addDelayReason_args()
6136 
    args.read(iprot)
6137 
    iprot.readMessageEnd()
6138 
    result = addDelayReason_result()
6139 
    try:
4647 rajveer 6140 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 6141 
    except TransactionServiceException, ex:
6142 
      result.ex = ex
6143 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
6144 
    result.write(oprot)
6145 
    oprot.writeMessageEnd()
6146 
    oprot.trans.flush()
3469 chandransh 6147 
 
3956 chandransh 6148 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
6149 
    args = reconcileCodCollection_args()
6150 
    args.read(iprot)
6151 
    iprot.readMessageEnd()
6152 
    result = reconcileCodCollection_result()
6153 
    try:
6154 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
6155 
    except TransactionServiceException, ex:
6156 
      result.ex = ex
6157 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
6158 
    result.write(oprot)
6159 
    oprot.writeMessageEnd()
6160 
    oprot.trans.flush()
3553 chandransh 6161 
 
4008 mandeep.dh 6162 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
6163 
    args = getTransactionsRequiringExtraProcessing_args()
6164 
    args.read(iprot)
6165 
    iprot.readMessageEnd()
6166 
    result = getTransactionsRequiringExtraProcessing_result()
6167 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
6168 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
6169 
    result.write(oprot)
6170 
    oprot.writeMessageEnd()
6171 
    oprot.trans.flush()
3956 chandransh 6172 
 
4008 mandeep.dh 6173 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
6174 
    args = markTransactionAsProcessed_args()
6175 
    args.read(iprot)
6176 
    iprot.readMessageEnd()
6177 
    result = markTransactionAsProcessed_result()
6178 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
6179 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
6180 
    result.write(oprot)
6181 
    oprot.writeMessageEnd()
6182 
    oprot.trans.flush()
6183 
 
4018 chandransh 6184 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
6185 
    args = getItemWiseRiskyOrdersCount_args()
6186 
    args.read(iprot)
6187 
    iprot.readMessageEnd()
6188 
    result = getItemWiseRiskyOrdersCount_result()
6189 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
6190 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
6191 
    result.write(oprot)
6192 
    oprot.writeMessageEnd()
6193 
    oprot.trans.flush()
4008 mandeep.dh 6194 
 
4295 varun.gupt 6195 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
6196 
    args = getOrdersForItemIds_args()
6197 
    args.read(iprot)
6198 
    iprot.readMessageEnd()
6199 
    result = getOrdersForItemIds_result()
6200 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
6201 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
6202 
    result.write(oprot)
6203 
    oprot.writeMessageEnd()
6204 
    oprot.trans.flush()
6205 
 
4247 rajveer 6206 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
6207 
    args = markOrderCancellationRequestReceived_args()
6208 
    args.read(iprot)
6209 
    iprot.readMessageEnd()
6210 
    result = markOrderCancellationRequestReceived_result()
6211 
    try:
6212 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
6213 
    except TransactionServiceException, ex:
6214 
      result.ex = ex
6215 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
6216 
    result.write(oprot)
6217 
    oprot.writeMessageEnd()
6218 
    oprot.trans.flush()
4018 chandransh 6219 
 
4247 rajveer 6220 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
6221 
    args = markOrderCancellationRequestConfirmed_args()
6222 
    args.read(iprot)
6223 
    iprot.readMessageEnd()
6224 
    result = markOrderCancellationRequestConfirmed_result()
6225 
    try:
6226 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
6227 
    except TransactionServiceException, ex:
6228 
      result.ex = ex
6229 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
6230 
    result.write(oprot)
6231 
    oprot.writeMessageEnd()
6232 
    oprot.trans.flush()
6233 
 
6234 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
6235 
    args = markOrderCancellationRequestDenied_args()
6236 
    args.read(iprot)
6237 
    iprot.readMessageEnd()
6238 
    result = markOrderCancellationRequestDenied_result()
6239 
    try:
6240 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
6241 
    except TransactionServiceException, ex:
6242 
      result.ex = ex
6243 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
6244 
    result.write(oprot)
6245 
    oprot.writeMessageEnd()
6246 
    oprot.trans.flush()
6247 
 
4258 rajveer 6248 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
6249 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 6250 
    args.read(iprot)
6251 
    iprot.readMessageEnd()
4258 rajveer 6252 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 6253 
    try:
4258 rajveer 6254 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 6255 
    except TransactionServiceException, ex:
6256 
      result.ex = ex
4258 rajveer 6257 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 6258 
    result.write(oprot)
6259 
    oprot.writeMessageEnd()
6260 
    oprot.trans.flush()
6261 
 
4259 anupam.sin 6262 
  def process_refundTransaction(self, seqid, iprot, oprot):
6263 
    args = refundTransaction_args()
6264 
    args.read(iprot)
6265 
    iprot.readMessageEnd()
6266 
    result = refundTransaction_result()
6267 
    try:
6268 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
6269 
    except TransactionServiceException, ex:
6270 
      result.ex = ex
6271 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
6272 
    result.write(oprot)
6273 
    oprot.writeMessageEnd()
6274 
    oprot.trans.flush()
4247 rajveer 6275 
 
4324 mandeep.dh 6276 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
6277 
    args = updateShipmentAddress_args()
6278 
    args.read(iprot)
6279 
    iprot.readMessageEnd()
6280 
    result = updateShipmentAddress_result()
6281 
    try:
6282 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
6283 
    except TransactionServiceException, ex:
6284 
      result.ex = ex
6285 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
6286 
    result.write(oprot)
6287 
    oprot.writeMessageEnd()
6288 
    oprot.trans.flush()
6289 
 
4285 rajveer 6290 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
6291 
    args = acceptOrdersForItemId_args()
6292 
    args.read(iprot)
6293 
    iprot.readMessageEnd()
6294 
    result = acceptOrdersForItemId_result()
6295 
    try:
6296 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
6297 
    except TransactionServiceException, ex:
6298 
      result.ex = ex
6299 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
6300 
    result.write(oprot)
6301 
    oprot.writeMessageEnd()
6302 
    oprot.trans.flush()
4259 anupam.sin 6303 
 
4303 rajveer 6304 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
6305 
    args = markOrdersAsPORaised_args()
6306 
    args.read(iprot)
6307 
    iprot.readMessageEnd()
6308 
    result = markOrdersAsPORaised_result()
6309 
    try:
4369 rajveer 6310 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6311 
    except TransactionServiceException, ex:
6312 
      result.ex = ex
6313 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
6314 
    result.write(oprot)
6315 
    oprot.writeMessageEnd()
6316 
    oprot.trans.flush()
4285 rajveer 6317 
 
4303 rajveer 6318 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
6319 
    args = markOrdersAsReversalInitiated_args()
6320 
    args.read(iprot)
6321 
    iprot.readMessageEnd()
6322 
    result = markOrdersAsReversalInitiated_result()
6323 
    try:
4369 rajveer 6324 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6325 
    except TransactionServiceException, ex:
6326 
      result.ex = ex
6327 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
6328 
    result.write(oprot)
6329 
    oprot.writeMessageEnd()
6330 
    oprot.trans.flush()
6331 
 
6332 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
6333 
    args = markOrdersAsNotAvailabke_args()
6334 
    args.read(iprot)
6335 
    iprot.readMessageEnd()
6336 
    result = markOrdersAsNotAvailabke_result()
6337 
    try:
4369 rajveer 6338 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6339 
    except TransactionServiceException, ex:
6340 
      result.ex = ex
6341 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
6342 
    result.write(oprot)
6343 
    oprot.writeMessageEnd()
6344 
    oprot.trans.flush()
6345 
 
4369 rajveer 6346 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
6347 
    args = markOrdersAsTimeout_args()
6348 
    args.read(iprot)
6349 
    iprot.readMessageEnd()
6350 
    result = markOrdersAsTimeout_result()
6351 
    try:
6352 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
6353 
    except TransactionServiceException, ex:
6354 
      result.ex = ex
6355 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
6356 
    result.write(oprot)
6357 
    oprot.writeMessageEnd()
6358 
    oprot.trans.flush()
4303 rajveer 6359 
 
4662 rajveer 6360 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
6361 
    args = markOrderAsLostInTransit_args()
6362 
    args.read(iprot)
6363 
    iprot.readMessageEnd()
6364 
    result = markOrderAsLostInTransit_result()
6365 
    try:
6366 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
6367 
    except TransactionServiceException, ex:
6368 
      result.ex = ex
6369 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
6370 
    result.write(oprot)
6371 
    oprot.writeMessageEnd()
6372 
    oprot.trans.flush()
6373 
 
4386 anupam.sin 6374 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
6375 
    args = getOrderForAwb_args()
6376 
    args.read(iprot)
6377 
    iprot.readMessageEnd()
6378 
    result = getOrderForAwb_result()
6379 
    try:
6380 
      result.success = self._handler.getOrderForAwb(args.awb)
6381 
    except TransactionServiceException, ex:
6382 
      result.ex = ex
6383 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
6384 
    result.write(oprot)
6385 
    oprot.writeMessageEnd()
6386 
    oprot.trans.flush()
4369 rajveer 6387 
 
4506 phani.kuma 6388 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
6389 
    args = getOrdersForProviderForStatus_args()
6390 
    args.read(iprot)
6391 
    iprot.readMessageEnd()
6392 
    result = getOrdersForProviderForStatus_result()
6393 
    try:
4910 phani.kuma 6394 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 6395 
    except TransactionServiceException, ex:
6396 
      result.ex = ex
6397 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
6398 
    result.write(oprot)
6399 
    oprot.writeMessageEnd()
6400 
    oprot.trans.flush()
4386 anupam.sin 6401 
 
4600 varun.gupt 6402 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
6403 
    args = getBilledOrdersForVendor_args()
6404 
    args.read(iprot)
6405 
    iprot.readMessageEnd()
6406 
    result = getBilledOrdersForVendor_result()
6407 
    try:
6408 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
6409 
    except TransactionServiceException, ex:
6410 
      result.ex = ex
6411 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
6412 
    result.write(oprot)
6413 
    oprot.writeMessageEnd()
6414 
    oprot.trans.flush()
4506 phani.kuma 6415 
 
4607 rajveer 6416 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
6417 
    args = getSlippedSippingDateOrders_args()
6418 
    args.read(iprot)
6419 
    iprot.readMessageEnd()
6420 
    result = getSlippedSippingDateOrders_result()
6421 
    try:
6422 
      result.success = self._handler.getSlippedSippingDateOrders()
6423 
    except TransactionServiceException, ex:
6424 
      result.ex = ex
6425 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
6426 
    result.write(oprot)
6427 
    oprot.writeMessageEnd()
6428 
    oprot.trans.flush()
6429 
 
4709 rajveer 6430 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
6431 
    args = getCancelledOrders_args()
6432 
    args.read(iprot)
6433 
    iprot.readMessageEnd()
6434 
    result = getCancelledOrders_result()
6435 
    try:
6436 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
6437 
    except TransactionServiceException, ex:
6438 
      result.ex = ex
6439 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
6440 
    result.write(oprot)
6441 
    oprot.writeMessageEnd()
6442 
    oprot.trans.flush()
6443 
 
4600 varun.gupt 6444 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
6445 
    args = saveBluedartSettlements_args()
6446 
    args.read(iprot)
6447 
    iprot.readMessageEnd()
6448 
    result = saveBluedartSettlements_result()
6449 
    try:
6450 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
6451 
    except TransactionServiceException, ex:
6452 
      result.ex = ex
6453 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
6454 
    result.write(oprot)
6455 
    oprot.writeMessageEnd()
6456 
    oprot.trans.flush()
6457 
 
6458 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
6459 
    args = savePaymentSettlements_args()
6460 
    args.read(iprot)
6461 
    iprot.readMessageEnd()
6462 
    result = savePaymentSettlements_result()
6463 
    try:
4905 varun.gupt 6464 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 6465 
    except TransactionServiceException, ex:
6466 
      result.ex = ex
6467 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
6468 
    result.write(oprot)
6469 
    oprot.writeMessageEnd()
6470 
    oprot.trans.flush()
6471 
 
6472 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
6473 
    args = saveEBSSettlementSummary_args()
6474 
    args.read(iprot)
6475 
    iprot.readMessageEnd()
6476 
    result = saveEBSSettlementSummary_result()
6477 
    try:
6478 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
6479 
    except TransactionServiceException, ex:
6480 
      result.ex = ex
6481 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
6482 
    result.write(oprot)
6483 
    oprot.writeMessageEnd()
6484 
    oprot.trans.flush()
6485 
 
5189 varun.gupt 6486 
  def process_getSettlementForReferenceId(self, seqid, iprot, oprot):
6487 
    args = getSettlementForReferenceId_args()
4600 varun.gupt 6488 
    args.read(iprot)
6489 
    iprot.readMessageEnd()
5189 varun.gupt 6490 
    result = getSettlementForReferenceId_result()
4600 varun.gupt 6491 
    try:
5189 varun.gupt 6492 
      result.success = self._handler.getSettlementForReferenceId(args.referenceId, args.isRefund)
4600 varun.gupt 6493 
    except TransactionServiceException, ex:
6494 
      result.ex = ex
5189 varun.gupt 6495 
    oprot.writeMessageBegin("getSettlementForReferenceId", TMessageType.REPLY, seqid)
4600 varun.gupt 6496 
    result.write(oprot)
6497 
    oprot.writeMessageEnd()
6498 
    oprot.trans.flush()
6499 
 
6500 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
6501 
    args = getEBSSettlementSummaries_args()
6502 
    args.read(iprot)
6503 
    iprot.readMessageEnd()
6504 
    result = getEBSSettlementSummaries_result()
6505 
    try:
6506 
      result.success = self._handler.getEBSSettlementSummaries()
6507 
    except TransactionServiceException, ex:
6508 
      result.ex = ex
6509 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
6510 
    result.write(oprot)
6511 
    oprot.writeMessageEnd()
6512 
    oprot.trans.flush()
6513 
 
6514 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
6515 
    args = markEBSSettlementUploaded_args()
6516 
    args.read(iprot)
6517 
    iprot.readMessageEnd()
6518 
    result = markEBSSettlementUploaded_result()
6519 
    try:
6520 
      self._handler.markEBSSettlementUploaded(args.settlementId)
6521 
    except TransactionServiceException, ex:
6522 
      result.ex = ex
6523 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
6524 
    result.write(oprot)
6525 
    oprot.writeMessageEnd()
6526 
    oprot.trans.flush()
6527 
 
6528 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
6529 
    args = getEBSSettlementDate_args()
6530 
    args.read(iprot)
6531 
    iprot.readMessageEnd()
6532 
    result = getEBSSettlementDate_result()
6533 
    try:
6534 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
6535 
    except TransactionServiceException, ex:
6536 
      result.ex = ex
6537 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
6538 
    result.write(oprot)
6539 
    oprot.writeMessageEnd()
6540 
    oprot.trans.flush()
6541 
 
4715 varun.gupt 6542 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
6543 
    args = getSettlementsByDate_args()
6544 
    args.read(iprot)
6545 
    iprot.readMessageEnd()
6546 
    result = getSettlementsByDate_result()
6547 
    try:
6548 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
6549 
    except TransactionServiceException, ex:
6550 
      result.ex = ex
6551 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
6552 
    result.write(oprot)
6553 
    oprot.writeMessageEnd()
6554 
    oprot.trans.flush()
4600 varun.gupt 6555 
 
4715 varun.gupt 6556 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
6557 
    args = getReshippedOrderIds_args()
6558 
    args.read(iprot)
6559 
    iprot.readMessageEnd()
6560 
    result = getReshippedOrderIds_result()
6561 
    try:
6562 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
6563 
    except TransactionServiceException, ex:
6564 
      result.ex = ex
6565 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
6566 
    result.write(oprot)
6567 
    oprot.writeMessageEnd()
6568 
    oprot.trans.flush()
6569 
 
5348 anupam.sin 6570 
  def process_updateOrdersAsPORaised(self, seqid, iprot, oprot):
6571 
    args = updateOrdersAsPORaised_args()
6572 
    args.read(iprot)
6573 
    iprot.readMessageEnd()
6574 
    result = updateOrdersAsPORaised_result()
6575 
    try:
6576 
      self._handler.updateOrdersAsPORaised(args.itemIdQuantityMap, args.purchaseOrderId, args.warehouseId)
6577 
    except TransactionServiceException, ex:
6578 
      result.ex = ex
6579 
    oprot.writeMessageBegin("updateOrdersAsPORaised", TMessageType.REPLY, seqid)
6580 
    result.write(oprot)
6581 
    oprot.writeMessageEnd()
6582 
    oprot.trans.flush()
6583 
 
4875 varun.gupt 6584 
  def process_getOrdersWhereVendorNotPaid(self, seqid, iprot, oprot):
6585 
    args = getOrdersWhereVendorNotPaid_args()
6586 
    args.read(iprot)
6587 
    iprot.readMessageEnd()
6588 
    result = getOrdersWhereVendorNotPaid_result()
6589 
    try:
6590 
      result.success = self._handler.getOrdersWhereVendorNotPaid(args.vendorId)
6591 
    except TransactionServiceException, ex:
6592 
      result.ex = ex
6593 
    oprot.writeMessageBegin("getOrdersWhereVendorNotPaid", TMessageType.REPLY, seqid)
6594 
    result.write(oprot)
6595 
    oprot.writeMessageEnd()
6596 
    oprot.trans.flush()
4757 mandeep.dh 6597 
 
5031 varun.gupt 6598 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
6599 
    args = getStatusDistributionOfOrders_args()
6600 
    args.read(iprot)
6601 
    iprot.readMessageEnd()
6602 
    result = getStatusDistributionOfOrders_result()
6603 
    try:
6604 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
6605 
    except TransactionServiceException, ex:
6606 
      result.ex = ex
6607 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
6608 
    result.write(oprot)
6609 
    oprot.writeMessageEnd()
6610 
    oprot.trans.flush()
4875 varun.gupt 6611 
 
5067 varun.gupt 6612 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
6613 
    args = getOrderIdsForStatus_args()
6614 
    args.read(iprot)
6615 
    iprot.readMessageEnd()
6616 
    result = getOrderIdsForStatus_result()
6617 
    try:
6618 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
6619 
    except TransactionServiceException, ex:
6620 
      result.ex = ex
6621 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
6622 
    result.write(oprot)
6623 
    oprot.writeMessageEnd()
6624 
    oprot.trans.flush()
5031 varun.gupt 6625 
 
5348 anupam.sin 6626 
  def process_updateCODAgent(self, seqid, iprot, oprot):
6627 
    args = updateCODAgent_args()
6628 
    args.read(iprot)
6629 
    iprot.readMessageEnd()
6630 
    result = updateCODAgent_result()
6631 
    try:
6632 
      self._handler.updateCODAgent(args.agent, args.orderId)
6633 
    except TransactionServiceException, ex:
6634 
      result.ex = ex
6635 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
6636 
    result.write(oprot)
6637 
    oprot.writeMessageEnd()
6638 
    oprot.trans.flush()
6639 
 
5099 varun.gupt 6640 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
6641 
    args = updateOrderAsPaidToVendor_args()
6642 
    args.read(iprot)
6643 
    iprot.readMessageEnd()
6644 
    result = updateOrderAsPaidToVendor_result()
6645 
    try:
6646 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
6647 
    except TransactionServiceException, ex:
6648 
      result.ex = ex
6649 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
6650 
    result.write(oprot)
6651 
    oprot.writeMessageEnd()
6652 
    oprot.trans.flush()
5067 varun.gupt 6653 
 
5208 varun.gupt 6654 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
6655 
    args = getRefundedOrdersMarkedPaid_args()
6656 
    args.read(iprot)
6657 
    iprot.readMessageEnd()
6658 
    result = getRefundedOrdersMarkedPaid_result()
6659 
    try:
6660 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
6661 
    except TransactionServiceException, ex:
6662 
      result.ex = ex
6663 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
6664 
    result.write(oprot)
6665 
    oprot.writeMessageEnd()
6666 
    oprot.trans.flush()
5099 varun.gupt 6667 
 
5208 varun.gupt 6668 
 
94 ashish 6669 
# HELPER FUNCTIONS AND STRUCTURES
6670 
 
6671 
class createTransaction_args:
6672 
  """
6673 
  Attributes:
6674 
   - transaction
6675 
  """
6676 
 
6677 
  thrift_spec = (
6678 
    None, # 0
6679 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
6680 
  )
6681 
 
6682 
  def __init__(self, transaction=None,):
6683 
    self.transaction = transaction
6684 
 
6685 
  def read(self, iprot):
6686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6688 
      return
6689 
    iprot.readStructBegin()
6690 
    while True:
6691 
      (fname, ftype, fid) = iprot.readFieldBegin()
6692 
      if ftype == TType.STOP:
6693 
        break
6694 
      if fid == 1:
6695 
        if ftype == TType.STRUCT:
6696 
          self.transaction = Transaction()
6697 
          self.transaction.read(iprot)
6698 
        else:
6699 
          iprot.skip(ftype)
6700 
      else:
6701 
        iprot.skip(ftype)
6702 
      iprot.readFieldEnd()
6703 
    iprot.readStructEnd()
6704 
 
6705 
  def write(self, oprot):
6706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6708 
      return
6709 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 6710 
    if self.transaction is not None:
94 ashish 6711 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
6712 
      self.transaction.write(oprot)
6713 
      oprot.writeFieldEnd()
6714 
    oprot.writeFieldStop()
6715 
    oprot.writeStructEnd()
6716 
 
3431 rajveer 6717 
  def validate(self):
6718 
    return
6719 
 
6720 
 
94 ashish 6721 
  def __repr__(self):
6722 
    L = ['%s=%r' % (key, value)
6723 
      for key, value in self.__dict__.iteritems()]
6724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6725 
 
6726 
  def __eq__(self, other):
6727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6728 
 
6729 
  def __ne__(self, other):
6730 
    return not (self == other)
6731 
 
6732 
class createTransaction_result:
6733 
  """
6734 
  Attributes:
132 ashish 6735 
   - success
94 ashish 6736 
   - ex
6737 
  """
6738 
 
6739 
  thrift_spec = (
132 ashish 6740 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 6741 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6742 
  )
6743 
 
132 ashish 6744 
  def __init__(self, success=None, ex=None,):
6745 
    self.success = success
94 ashish 6746 
    self.ex = ex
6747 
 
6748 
  def read(self, iprot):
6749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6751 
      return
6752 
    iprot.readStructBegin()
6753 
    while True:
6754 
      (fname, ftype, fid) = iprot.readFieldBegin()
6755 
      if ftype == TType.STOP:
6756 
        break
132 ashish 6757 
      if fid == 0:
6758 
        if ftype == TType.I64:
6759 
          self.success = iprot.readI64();
6760 
        else:
6761 
          iprot.skip(ftype)
6762 
      elif fid == 1:
94 ashish 6763 
        if ftype == TType.STRUCT:
6764 
          self.ex = TransactionServiceException()
6765 
          self.ex.read(iprot)
6766 
        else:
6767 
          iprot.skip(ftype)
6768 
      else:
6769 
        iprot.skip(ftype)
6770 
      iprot.readFieldEnd()
6771 
    iprot.readStructEnd()
6772 
 
6773 
  def write(self, oprot):
6774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6776 
      return
6777 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 6778 
    if self.success is not None:
132 ashish 6779 
      oprot.writeFieldBegin('success', TType.I64, 0)
6780 
      oprot.writeI64(self.success)
6781 
      oprot.writeFieldEnd()
3431 rajveer 6782 
    if self.ex is not None:
94 ashish 6783 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6784 
      self.ex.write(oprot)
6785 
      oprot.writeFieldEnd()
6786 
    oprot.writeFieldStop()
6787 
    oprot.writeStructEnd()
6788 
 
3431 rajveer 6789 
  def validate(self):
6790 
    return
6791 
 
6792 
 
94 ashish 6793 
  def __repr__(self):
6794 
    L = ['%s=%r' % (key, value)
6795 
      for key, value in self.__dict__.iteritems()]
6796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6797 
 
6798 
  def __eq__(self, other):
6799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6800 
 
6801 
  def __ne__(self, other):
6802 
    return not (self == other)
6803 
 
6804 
class getTransaction_args:
6805 
  """
6806 
  Attributes:
6807 
   - id
6808 
  """
6809 
 
6810 
  thrift_spec = (
6811 
    None, # 0
6812 
    (1, TType.I64, 'id', None, None, ), # 1
6813 
  )
6814 
 
6815 
  def __init__(self, id=None,):
6816 
    self.id = id
6817 
 
6818 
  def read(self, iprot):
6819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6821 
      return
6822 
    iprot.readStructBegin()
6823 
    while True:
6824 
      (fname, ftype, fid) = iprot.readFieldBegin()
6825 
      if ftype == TType.STOP:
6826 
        break
6827 
      if fid == 1:
6828 
        if ftype == TType.I64:
6829 
          self.id = iprot.readI64();
6830 
        else:
6831 
          iprot.skip(ftype)
6832 
      else:
6833 
        iprot.skip(ftype)
6834 
      iprot.readFieldEnd()
6835 
    iprot.readStructEnd()
6836 
 
6837 
  def write(self, oprot):
6838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6840 
      return
6841 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 6842 
    if self.id is not None:
94 ashish 6843 
      oprot.writeFieldBegin('id', TType.I64, 1)
6844 
      oprot.writeI64(self.id)
6845 
      oprot.writeFieldEnd()
6846 
    oprot.writeFieldStop()
6847 
    oprot.writeStructEnd()
6848 
 
3431 rajveer 6849 
  def validate(self):
6850 
    return
6851 
 
6852 
 
94 ashish 6853 
  def __repr__(self):
6854 
    L = ['%s=%r' % (key, value)
6855 
      for key, value in self.__dict__.iteritems()]
6856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6857 
 
6858 
  def __eq__(self, other):
6859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6860 
 
6861 
  def __ne__(self, other):
6862 
    return not (self == other)
6863 
 
6864 
class getTransaction_result:
6865 
  """
6866 
  Attributes:
6867 
   - success
6868 
   - ex
6869 
  """
6870 
 
6871 
  thrift_spec = (
6872 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
6873 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6874 
  )
6875 
 
6876 
  def __init__(self, success=None, ex=None,):
6877 
    self.success = success
6878 
    self.ex = ex
6879 
 
6880 
  def read(self, iprot):
6881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6883 
      return
6884 
    iprot.readStructBegin()
6885 
    while True:
6886 
      (fname, ftype, fid) = iprot.readFieldBegin()
6887 
      if ftype == TType.STOP:
6888 
        break
6889 
      if fid == 0:
6890 
        if ftype == TType.STRUCT:
6891 
          self.success = Transaction()
6892 
          self.success.read(iprot)
6893 
        else:
6894 
          iprot.skip(ftype)
6895 
      elif fid == 1:
6896 
        if ftype == TType.STRUCT:
6897 
          self.ex = TransactionServiceException()
6898 
          self.ex.read(iprot)
6899 
        else:
6900 
          iprot.skip(ftype)
6901 
      else:
6902 
        iprot.skip(ftype)
6903 
      iprot.readFieldEnd()
6904 
    iprot.readStructEnd()
6905 
 
6906 
  def write(self, oprot):
6907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6909 
      return
6910 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 6911 
    if self.success is not None:
94 ashish 6912 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6913 
      self.success.write(oprot)
6914 
      oprot.writeFieldEnd()
3431 rajveer 6915 
    if self.ex is not None:
94 ashish 6916 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6917 
      self.ex.write(oprot)
6918 
      oprot.writeFieldEnd()
6919 
    oprot.writeFieldStop()
6920 
    oprot.writeStructEnd()
6921 
 
3431 rajveer 6922 
  def validate(self):
6923 
    return
6924 
 
6925 
 
94 ashish 6926 
  def __repr__(self):
6927 
    L = ['%s=%r' % (key, value)
6928 
      for key, value in self.__dict__.iteritems()]
6929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6930 
 
6931 
  def __eq__(self, other):
6932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6933 
 
6934 
  def __ne__(self, other):
6935 
    return not (self == other)
6936 
 
6937 
class getTransactionsForCustomer_args:
6938 
  """
6939 
  Attributes:
6940 
   - customerId
6941 
   - from_date
6942 
   - to_date
6943 
   - status
6944 
  """
6945 
 
6946 
  thrift_spec = (
6947 
    None, # 0
6948 
    (1, TType.I64, 'customerId', None, None, ), # 1
6949 
    (2, TType.I64, 'from_date', None, None, ), # 2
6950 
    (3, TType.I64, 'to_date', None, None, ), # 3
6951 
    (4, TType.I32, 'status', None, None, ), # 4
6952 
  )
6953 
 
6954 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
6955 
    self.customerId = customerId
6956 
    self.from_date = from_date
6957 
    self.to_date = to_date
6958 
    self.status = status
6959 
 
6960 
  def read(self, iprot):
6961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6963 
      return
6964 
    iprot.readStructBegin()
6965 
    while True:
6966 
      (fname, ftype, fid) = iprot.readFieldBegin()
6967 
      if ftype == TType.STOP:
6968 
        break
6969 
      if fid == 1:
6970 
        if ftype == TType.I64:
6971 
          self.customerId = iprot.readI64();
6972 
        else:
6973 
          iprot.skip(ftype)
6974 
      elif fid == 2:
6975 
        if ftype == TType.I64:
6976 
          self.from_date = iprot.readI64();
6977 
        else:
6978 
          iprot.skip(ftype)
6979 
      elif fid == 3:
6980 
        if ftype == TType.I64:
6981 
          self.to_date = iprot.readI64();
6982 
        else:
6983 
          iprot.skip(ftype)
6984 
      elif fid == 4:
6985 
        if ftype == TType.I32:
6986 
          self.status = iprot.readI32();
6987 
        else:
6988 
          iprot.skip(ftype)
6989 
      else:
6990 
        iprot.skip(ftype)
6991 
      iprot.readFieldEnd()
6992 
    iprot.readStructEnd()
6993 
 
6994 
  def write(self, oprot):
6995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6997 
      return
6998 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 6999 
    if self.customerId is not None:
94 ashish 7000 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7001 
      oprot.writeI64(self.customerId)
7002 
      oprot.writeFieldEnd()
3431 rajveer 7003 
    if self.from_date is not None:
94 ashish 7004 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7005 
      oprot.writeI64(self.from_date)
7006 
      oprot.writeFieldEnd()
3431 rajveer 7007 
    if self.to_date is not None:
94 ashish 7008 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7009 
      oprot.writeI64(self.to_date)
7010 
      oprot.writeFieldEnd()
3431 rajveer 7011 
    if self.status is not None:
94 ashish 7012 
      oprot.writeFieldBegin('status', TType.I32, 4)
7013 
      oprot.writeI32(self.status)
7014 
      oprot.writeFieldEnd()
7015 
    oprot.writeFieldStop()
7016 
    oprot.writeStructEnd()
7017 
 
3431 rajveer 7018 
  def validate(self):
7019 
    return
7020 
 
7021 
 
94 ashish 7022 
  def __repr__(self):
7023 
    L = ['%s=%r' % (key, value)
7024 
      for key, value in self.__dict__.iteritems()]
7025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7026 
 
7027 
  def __eq__(self, other):
7028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7029 
 
7030 
  def __ne__(self, other):
7031 
    return not (self == other)
7032 
 
7033 
class getTransactionsForCustomer_result:
7034 
  """
7035 
  Attributes:
7036 
   - success
7037 
   - ex
7038 
  """
7039 
 
7040 
  thrift_spec = (
7041 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7042 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7043 
  )
7044 
 
7045 
  def __init__(self, success=None, ex=None,):
7046 
    self.success = success
7047 
    self.ex = ex
7048 
 
7049 
  def read(self, iprot):
7050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7052 
      return
7053 
    iprot.readStructBegin()
7054 
    while True:
7055 
      (fname, ftype, fid) = iprot.readFieldBegin()
7056 
      if ftype == TType.STOP:
7057 
        break
7058 
      if fid == 0:
7059 
        if ftype == TType.LIST:
7060 
          self.success = []
5031 varun.gupt 7061 
          (_etype66, _size63) = iprot.readListBegin()
7062 
          for _i67 in xrange(_size63):
7063 
            _elem68 = Transaction()
7064 
            _elem68.read(iprot)
7065 
            self.success.append(_elem68)
94 ashish 7066 
          iprot.readListEnd()
7067 
        else:
7068 
          iprot.skip(ftype)
7069 
      elif fid == 1:
7070 
        if ftype == TType.STRUCT:
7071 
          self.ex = TransactionServiceException()
7072 
          self.ex.read(iprot)
7073 
        else:
7074 
          iprot.skip(ftype)
7075 
      else:
7076 
        iprot.skip(ftype)
7077 
      iprot.readFieldEnd()
7078 
    iprot.readStructEnd()
7079 
 
7080 
  def write(self, oprot):
7081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7083 
      return
7084 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 7085 
    if self.success is not None:
94 ashish 7086 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7087 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7088 
      for iter69 in self.success:
7089 
        iter69.write(oprot)
94 ashish 7090 
      oprot.writeListEnd()
7091 
      oprot.writeFieldEnd()
3431 rajveer 7092 
    if self.ex is not None:
94 ashish 7093 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7094 
      self.ex.write(oprot)
7095 
      oprot.writeFieldEnd()
7096 
    oprot.writeFieldStop()
7097 
    oprot.writeStructEnd()
7098 
 
3431 rajveer 7099 
  def validate(self):
7100 
    return
7101 
 
7102 
 
94 ashish 7103 
  def __repr__(self):
7104 
    L = ['%s=%r' % (key, value)
7105 
      for key, value in self.__dict__.iteritems()]
7106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7107 
 
7108 
  def __eq__(self, other):
7109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7110 
 
7111 
  def __ne__(self, other):
7112 
    return not (self == other)
7113 
 
132 ashish 7114 
class getTransactionsForShoppingCartId_args:
7115 
  """
7116 
  Attributes:
7117 
   - shoppingCartId
7118 
  """
7119 
 
7120 
  thrift_spec = (
7121 
    None, # 0
7122 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
7123 
  )
7124 
 
7125 
  def __init__(self, shoppingCartId=None,):
7126 
    self.shoppingCartId = shoppingCartId
7127 
 
7128 
  def read(self, iprot):
7129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7131 
      return
7132 
    iprot.readStructBegin()
7133 
    while True:
7134 
      (fname, ftype, fid) = iprot.readFieldBegin()
7135 
      if ftype == TType.STOP:
7136 
        break
7137 
      if fid == 1:
7138 
        if ftype == TType.I64:
7139 
          self.shoppingCartId = iprot.readI64();
7140 
        else:
7141 
          iprot.skip(ftype)
7142 
      else:
7143 
        iprot.skip(ftype)
7144 
      iprot.readFieldEnd()
7145 
    iprot.readStructEnd()
7146 
 
7147 
  def write(self, oprot):
7148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7150 
      return
7151 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 7152 
    if self.shoppingCartId is not None:
132 ashish 7153 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
7154 
      oprot.writeI64(self.shoppingCartId)
7155 
      oprot.writeFieldEnd()
7156 
    oprot.writeFieldStop()
7157 
    oprot.writeStructEnd()
7158 
 
3431 rajveer 7159 
  def validate(self):
7160 
    return
7161 
 
7162 
 
132 ashish 7163 
  def __repr__(self):
7164 
    L = ['%s=%r' % (key, value)
7165 
      for key, value in self.__dict__.iteritems()]
7166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7167 
 
7168 
  def __eq__(self, other):
7169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7170 
 
7171 
  def __ne__(self, other):
7172 
    return not (self == other)
7173 
 
7174 
class getTransactionsForShoppingCartId_result:
7175 
  """
7176 
  Attributes:
7177 
   - success
7178 
   - ex
7179 
  """
7180 
 
7181 
  thrift_spec = (
7182 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7183 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7184 
  )
7185 
 
7186 
  def __init__(self, success=None, ex=None,):
7187 
    self.success = success
7188 
    self.ex = ex
7189 
 
7190 
  def read(self, iprot):
7191 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7192 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7193 
      return
7194 
    iprot.readStructBegin()
7195 
    while True:
7196 
      (fname, ftype, fid) = iprot.readFieldBegin()
7197 
      if ftype == TType.STOP:
7198 
        break
7199 
      if fid == 0:
7200 
        if ftype == TType.LIST:
7201 
          self.success = []
5031 varun.gupt 7202 
          (_etype73, _size70) = iprot.readListBegin()
7203 
          for _i74 in xrange(_size70):
7204 
            _elem75 = Transaction()
7205 
            _elem75.read(iprot)
7206 
            self.success.append(_elem75)
132 ashish 7207 
          iprot.readListEnd()
7208 
        else:
7209 
          iprot.skip(ftype)
7210 
      elif fid == 1:
7211 
        if ftype == TType.STRUCT:
7212 
          self.ex = TransactionServiceException()
7213 
          self.ex.read(iprot)
7214 
        else:
7215 
          iprot.skip(ftype)
7216 
      else:
7217 
        iprot.skip(ftype)
7218 
      iprot.readFieldEnd()
7219 
    iprot.readStructEnd()
7220 
 
7221 
  def write(self, oprot):
7222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7224 
      return
7225 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 7226 
    if self.success is not None:
132 ashish 7227 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7228 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7229 
      for iter76 in self.success:
7230 
        iter76.write(oprot)
132 ashish 7231 
      oprot.writeListEnd()
7232 
      oprot.writeFieldEnd()
3431 rajveer 7233 
    if self.ex is not None:
132 ashish 7234 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7235 
      self.ex.write(oprot)
7236 
      oprot.writeFieldEnd()
7237 
    oprot.writeFieldStop()
7238 
    oprot.writeStructEnd()
7239 
 
3431 rajveer 7240 
  def validate(self):
7241 
    return
7242 
 
7243 
 
132 ashish 7244 
  def __repr__(self):
7245 
    L = ['%s=%r' % (key, value)
7246 
      for key, value in self.__dict__.iteritems()]
7247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7248 
 
7249 
  def __eq__(self, other):
7250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7251 
 
7252 
  def __ne__(self, other):
7253 
    return not (self == other)
7254 
 
94 ashish 7255 
class getTransactionStatus_args:
7256 
  """
7257 
  Attributes:
7258 
   - transactionId
7259 
  """
7260 
 
7261 
  thrift_spec = (
7262 
    None, # 0
7263 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7264 
  )
7265 
 
7266 
  def __init__(self, transactionId=None,):
7267 
    self.transactionId = transactionId
7268 
 
7269 
  def read(self, iprot):
7270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7272 
      return
7273 
    iprot.readStructBegin()
7274 
    while True:
7275 
      (fname, ftype, fid) = iprot.readFieldBegin()
7276 
      if ftype == TType.STOP:
7277 
        break
7278 
      if fid == 1:
7279 
        if ftype == TType.I64:
7280 
          self.transactionId = iprot.readI64();
7281 
        else:
7282 
          iprot.skip(ftype)
7283 
      else:
7284 
        iprot.skip(ftype)
7285 
      iprot.readFieldEnd()
7286 
    iprot.readStructEnd()
7287 
 
7288 
  def write(self, oprot):
7289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7291 
      return
7292 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 7293 
    if self.transactionId is not None:
94 ashish 7294 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7295 
      oprot.writeI64(self.transactionId)
7296 
      oprot.writeFieldEnd()
7297 
    oprot.writeFieldStop()
7298 
    oprot.writeStructEnd()
7299 
 
3431 rajveer 7300 
  def validate(self):
7301 
    return
7302 
 
7303 
 
94 ashish 7304 
  def __repr__(self):
7305 
    L = ['%s=%r' % (key, value)
7306 
      for key, value in self.__dict__.iteritems()]
7307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7308 
 
7309 
  def __eq__(self, other):
7310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7311 
 
7312 
  def __ne__(self, other):
7313 
    return not (self == other)
7314 
 
7315 
class getTransactionStatus_result:
7316 
  """
7317 
  Attributes:
7318 
   - success
7319 
   - ex
7320 
  """
7321 
 
7322 
  thrift_spec = (
7323 
    (0, TType.I32, 'success', None, None, ), # 0
7324 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7325 
  )
7326 
 
7327 
  def __init__(self, success=None, ex=None,):
7328 
    self.success = success
7329 
    self.ex = ex
7330 
 
7331 
  def read(self, iprot):
7332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7334 
      return
7335 
    iprot.readStructBegin()
7336 
    while True:
7337 
      (fname, ftype, fid) = iprot.readFieldBegin()
7338 
      if ftype == TType.STOP:
7339 
        break
7340 
      if fid == 0:
7341 
        if ftype == TType.I32:
7342 
          self.success = iprot.readI32();
7343 
        else:
7344 
          iprot.skip(ftype)
7345 
      elif fid == 1:
7346 
        if ftype == TType.STRUCT:
7347 
          self.ex = TransactionServiceException()
7348 
          self.ex.read(iprot)
7349 
        else:
7350 
          iprot.skip(ftype)
7351 
      else:
7352 
        iprot.skip(ftype)
7353 
      iprot.readFieldEnd()
7354 
    iprot.readStructEnd()
7355 
 
7356 
  def write(self, oprot):
7357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7359 
      return
7360 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 7361 
    if self.success is not None:
94 ashish 7362 
      oprot.writeFieldBegin('success', TType.I32, 0)
7363 
      oprot.writeI32(self.success)
7364 
      oprot.writeFieldEnd()
3431 rajveer 7365 
    if self.ex is not None:
94 ashish 7366 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7367 
      self.ex.write(oprot)
7368 
      oprot.writeFieldEnd()
7369 
    oprot.writeFieldStop()
7370 
    oprot.writeStructEnd()
7371 
 
3431 rajveer 7372 
  def validate(self):
7373 
    return
7374 
 
7375 
 
94 ashish 7376 
  def __repr__(self):
7377 
    L = ['%s=%r' % (key, value)
7378 
      for key, value in self.__dict__.iteritems()]
7379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7380 
 
7381 
  def __eq__(self, other):
7382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7383 
 
7384 
  def __ne__(self, other):
7385 
    return not (self == other)
7386 
 
7387 
class changeTransactionStatus_args:
7388 
  """
7389 
  Attributes:
7390 
   - transactionId
7391 
   - status
7392 
   - description
7393 
  """
7394 
 
7395 
  thrift_spec = (
7396 
    None, # 0
7397 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7398 
    (2, TType.I32, 'status', None, None, ), # 2
7399 
    (3, TType.STRING, 'description', None, None, ), # 3
7400 
  )
7401 
 
7402 
  def __init__(self, transactionId=None, status=None, description=None,):
7403 
    self.transactionId = transactionId
7404 
    self.status = status
7405 
    self.description = description
7406 
 
7407 
  def read(self, iprot):
7408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7410 
      return
7411 
    iprot.readStructBegin()
7412 
    while True:
7413 
      (fname, ftype, fid) = iprot.readFieldBegin()
7414 
      if ftype == TType.STOP:
7415 
        break
7416 
      if fid == 1:
7417 
        if ftype == TType.I64:
7418 
          self.transactionId = iprot.readI64();
7419 
        else:
7420 
          iprot.skip(ftype)
7421 
      elif fid == 2:
7422 
        if ftype == TType.I32:
7423 
          self.status = iprot.readI32();
7424 
        else:
7425 
          iprot.skip(ftype)
7426 
      elif fid == 3:
7427 
        if ftype == TType.STRING:
7428 
          self.description = iprot.readString();
7429 
        else:
7430 
          iprot.skip(ftype)
7431 
      else:
7432 
        iprot.skip(ftype)
7433 
      iprot.readFieldEnd()
7434 
    iprot.readStructEnd()
7435 
 
7436 
  def write(self, oprot):
7437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7439 
      return
7440 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 7441 
    if self.transactionId is not None:
94 ashish 7442 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7443 
      oprot.writeI64(self.transactionId)
7444 
      oprot.writeFieldEnd()
3431 rajveer 7445 
    if self.status is not None:
94 ashish 7446 
      oprot.writeFieldBegin('status', TType.I32, 2)
7447 
      oprot.writeI32(self.status)
7448 
      oprot.writeFieldEnd()
3431 rajveer 7449 
    if self.description is not None:
94 ashish 7450 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7451 
      oprot.writeString(self.description)
7452 
      oprot.writeFieldEnd()
7453 
    oprot.writeFieldStop()
7454 
    oprot.writeStructEnd()
7455 
 
3431 rajveer 7456 
  def validate(self):
7457 
    return
7458 
 
7459 
 
94 ashish 7460 
  def __repr__(self):
7461 
    L = ['%s=%r' % (key, value)
7462 
      for key, value in self.__dict__.iteritems()]
7463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7464 
 
7465 
  def __eq__(self, other):
7466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7467 
 
7468 
  def __ne__(self, other):
7469 
    return not (self == other)
7470 
 
7471 
class changeTransactionStatus_result:
7472 
  """
7473 
  Attributes:
7474 
   - success
7475 
   - ex
7476 
  """
7477 
 
7478 
  thrift_spec = (
7479 
    (0, TType.BOOL, 'success', None, None, ), # 0
7480 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7481 
  )
7482 
 
7483 
  def __init__(self, success=None, ex=None,):
7484 
    self.success = success
7485 
    self.ex = ex
7486 
 
7487 
  def read(self, iprot):
7488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7490 
      return
7491 
    iprot.readStructBegin()
7492 
    while True:
7493 
      (fname, ftype, fid) = iprot.readFieldBegin()
7494 
      if ftype == TType.STOP:
7495 
        break
7496 
      if fid == 0:
7497 
        if ftype == TType.BOOL:
7498 
          self.success = iprot.readBool();
7499 
        else:
7500 
          iprot.skip(ftype)
7501 
      elif fid == 1:
7502 
        if ftype == TType.STRUCT:
7503 
          self.ex = TransactionServiceException()
7504 
          self.ex.read(iprot)
7505 
        else:
7506 
          iprot.skip(ftype)
7507 
      else:
7508 
        iprot.skip(ftype)
7509 
      iprot.readFieldEnd()
7510 
    iprot.readStructEnd()
7511 
 
7512 
  def write(self, oprot):
7513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7515 
      return
7516 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 7517 
    if self.success is not None:
94 ashish 7518 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7519 
      oprot.writeBool(self.success)
7520 
      oprot.writeFieldEnd()
3431 rajveer 7521 
    if self.ex is not None:
94 ashish 7522 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7523 
      self.ex.write(oprot)
7524 
      oprot.writeFieldEnd()
7525 
    oprot.writeFieldStop()
7526 
    oprot.writeStructEnd()
7527 
 
3431 rajveer 7528 
  def validate(self):
7529 
    return
7530 
 
7531 
 
94 ashish 7532 
  def __repr__(self):
7533 
    L = ['%s=%r' % (key, value)
7534 
      for key, value in self.__dict__.iteritems()]
7535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7536 
 
7537 
  def __eq__(self, other):
7538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7539 
 
7540 
  def __ne__(self, other):
7541 
    return not (self == other)
7542 
 
1398 varun.gupt 7543 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 7544 
  """
7545 
  Attributes:
7546 
   - transactionId
7547 
  """
7548 
 
7549 
  thrift_spec = (
7550 
    None, # 0
7551 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7552 
  )
7553 
 
7554 
  def __init__(self, transactionId=None,):
7555 
    self.transactionId = transactionId
7556 
 
7557 
  def read(self, iprot):
7558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7560 
      return
7561 
    iprot.readStructBegin()
7562 
    while True:
7563 
      (fname, ftype, fid) = iprot.readFieldBegin()
7564 
      if ftype == TType.STOP:
7565 
        break
7566 
      if fid == 1:
7567 
        if ftype == TType.I64:
7568 
          self.transactionId = iprot.readI64();
7569 
        else:
7570 
          iprot.skip(ftype)
7571 
      else:
7572 
        iprot.skip(ftype)
7573 
      iprot.readFieldEnd()
7574 
    iprot.readStructEnd()
7575 
 
7576 
  def write(self, oprot):
7577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7579 
      return
1398 varun.gupt 7580 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 7581 
    if self.transactionId is not None:
1382 varun.gupt 7582 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7583 
      oprot.writeI64(self.transactionId)
7584 
      oprot.writeFieldEnd()
7585 
    oprot.writeFieldStop()
7586 
    oprot.writeStructEnd()
7587 
 
3431 rajveer 7588 
  def validate(self):
7589 
    return
7590 
 
7591 
 
1382 varun.gupt 7592 
  def __repr__(self):
7593 
    L = ['%s=%r' % (key, value)
7594 
      for key, value in self.__dict__.iteritems()]
7595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7596 
 
7597 
  def __eq__(self, other):
7598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7599 
 
7600 
  def __ne__(self, other):
7601 
    return not (self == other)
7602 
 
1398 varun.gupt 7603 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 7604 
  """
7605 
  Attributes:
7606 
   - success
7607 
   - ex
7608 
  """
7609 
 
7610 
  thrift_spec = (
7611 
    (0, TType.BOOL, 'success', None, None, ), # 0
7612 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7613 
  )
7614 
 
7615 
  def __init__(self, success=None, ex=None,):
7616 
    self.success = success
7617 
    self.ex = ex
7618 
 
7619 
  def read(self, iprot):
7620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7622 
      return
7623 
    iprot.readStructBegin()
7624 
    while True:
7625 
      (fname, ftype, fid) = iprot.readFieldBegin()
7626 
      if ftype == TType.STOP:
7627 
        break
7628 
      if fid == 0:
7629 
        if ftype == TType.BOOL:
7630 
          self.success = iprot.readBool();
7631 
        else:
7632 
          iprot.skip(ftype)
7633 
      elif fid == 1:
7634 
        if ftype == TType.STRUCT:
7635 
          self.ex = TransactionServiceException()
7636 
          self.ex.read(iprot)
7637 
        else:
7638 
          iprot.skip(ftype)
7639 
      else:
7640 
        iprot.skip(ftype)
7641 
      iprot.readFieldEnd()
7642 
    iprot.readStructEnd()
7643 
 
7644 
  def write(self, oprot):
7645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7647 
      return
1398 varun.gupt 7648 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 7649 
    if self.success is not None:
1382 varun.gupt 7650 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7651 
      oprot.writeBool(self.success)
7652 
      oprot.writeFieldEnd()
3431 rajveer 7653 
    if self.ex is not None:
1382 varun.gupt 7654 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7655 
      self.ex.write(oprot)
7656 
      oprot.writeFieldEnd()
7657 
    oprot.writeFieldStop()
7658 
    oprot.writeStructEnd()
7659 
 
3431 rajveer 7660 
  def validate(self):
7661 
    return
7662 
 
7663 
 
1382 varun.gupt 7664 
  def __repr__(self):
7665 
    L = ['%s=%r' % (key, value)
7666 
      for key, value in self.__dict__.iteritems()]
7667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7668 
 
7669 
  def __eq__(self, other):
7670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7671 
 
7672 
  def __ne__(self, other):
7673 
    return not (self == other)
7674 
 
483 rajveer 7675 
class getAllOrders_args:
94 ashish 7676 
  """
7677 
  Attributes:
4801 anupam.sin 7678 
   - statuses
483 rajveer 7679 
   - from_date
7680 
   - to_date
7681 
   - warehouse_id
94 ashish 7682 
  """
7683 
 
7684 
  thrift_spec = (
7685 
    None, # 0
4801 anupam.sin 7686 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 7687 
    (2, TType.I64, 'from_date', None, None, ), # 2
7688 
    (3, TType.I64, 'to_date', None, None, ), # 3
7689 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 7690 
  )
7691 
 
4801 anupam.sin 7692 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
7693 
    self.statuses = statuses
483 rajveer 7694 
    self.from_date = from_date
7695 
    self.to_date = to_date
7696 
    self.warehouse_id = warehouse_id
94 ashish 7697 
 
7698 
  def read(self, iprot):
7699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7701 
      return
7702 
    iprot.readStructBegin()
7703 
    while True:
7704 
      (fname, ftype, fid) = iprot.readFieldBegin()
7705 
      if ftype == TType.STOP:
7706 
        break
7707 
      if fid == 1:
4801 anupam.sin 7708 
        if ftype == TType.LIST:
7709 
          self.statuses = []
5031 varun.gupt 7710 
          (_etype80, _size77) = iprot.readListBegin()
7711 
          for _i81 in xrange(_size77):
7712 
            _elem82 = iprot.readI32();
7713 
            self.statuses.append(_elem82)
4801 anupam.sin 7714 
          iprot.readListEnd()
94 ashish 7715 
        else:
7716 
          iprot.skip(ftype)
483 rajveer 7717 
      elif fid == 2:
7718 
        if ftype == TType.I64:
7719 
          self.from_date = iprot.readI64();
94 ashish 7720 
        else:
7721 
          iprot.skip(ftype)
483 rajveer 7722 
      elif fid == 3:
7723 
        if ftype == TType.I64:
7724 
          self.to_date = iprot.readI64();
94 ashish 7725 
        else:
7726 
          iprot.skip(ftype)
483 rajveer 7727 
      elif fid == 4:
94 ashish 7728 
        if ftype == TType.I64:
483 rajveer 7729 
          self.warehouse_id = iprot.readI64();
94 ashish 7730 
        else:
7731 
          iprot.skip(ftype)
7732 
      else:
7733 
        iprot.skip(ftype)
7734 
      iprot.readFieldEnd()
7735 
    iprot.readStructEnd()
7736 
 
7737 
  def write(self, oprot):
7738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7740 
      return
483 rajveer 7741 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 7742 
    if self.statuses is not None:
7743 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7744 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7745 
      for iter83 in self.statuses:
7746 
        oprot.writeI32(iter83)
4801 anupam.sin 7747 
      oprot.writeListEnd()
94 ashish 7748 
      oprot.writeFieldEnd()
3431 rajveer 7749 
    if self.from_date is not None:
483 rajveer 7750 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7751 
      oprot.writeI64(self.from_date)
94 ashish 7752 
      oprot.writeFieldEnd()
3431 rajveer 7753 
    if self.to_date is not None:
483 rajveer 7754 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7755 
      oprot.writeI64(self.to_date)
94 ashish 7756 
      oprot.writeFieldEnd()
3431 rajveer 7757 
    if self.warehouse_id is not None:
483 rajveer 7758 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7759 
      oprot.writeI64(self.warehouse_id)
94 ashish 7760 
      oprot.writeFieldEnd()
7761 
    oprot.writeFieldStop()
7762 
    oprot.writeStructEnd()
7763 
 
3431 rajveer 7764 
  def validate(self):
7765 
    return
7766 
 
7767 
 
94 ashish 7768 
  def __repr__(self):
7769 
    L = ['%s=%r' % (key, value)
7770 
      for key, value in self.__dict__.iteritems()]
7771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7772 
 
7773 
  def __eq__(self, other):
7774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7775 
 
7776 
  def __ne__(self, other):
7777 
    return not (self == other)
7778 
 
483 rajveer 7779 
class getAllOrders_result:
94 ashish 7780 
  """
7781 
  Attributes:
7782 
   - success
7783 
   - ex
7784 
  """
7785 
 
7786 
  thrift_spec = (
483 rajveer 7787 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 7788 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7789 
  )
7790 
 
7791 
  def __init__(self, success=None, ex=None,):
7792 
    self.success = success
7793 
    self.ex = ex
7794 
 
7795 
  def read(self, iprot):
7796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7798 
      return
7799 
    iprot.readStructBegin()
7800 
    while True:
7801 
      (fname, ftype, fid) = iprot.readFieldBegin()
7802 
      if ftype == TType.STOP:
7803 
        break
7804 
      if fid == 0:
483 rajveer 7805 
        if ftype == TType.LIST:
7806 
          self.success = []
5031 varun.gupt 7807 
          (_etype87, _size84) = iprot.readListBegin()
7808 
          for _i88 in xrange(_size84):
7809 
            _elem89 = Order()
7810 
            _elem89.read(iprot)
7811 
            self.success.append(_elem89)
483 rajveer 7812 
          iprot.readListEnd()
94 ashish 7813 
        else:
7814 
          iprot.skip(ftype)
7815 
      elif fid == 1:
7816 
        if ftype == TType.STRUCT:
7817 
          self.ex = TransactionServiceException()
7818 
          self.ex.read(iprot)
7819 
        else:
7820 
          iprot.skip(ftype)
7821 
      else:
7822 
        iprot.skip(ftype)
7823 
      iprot.readFieldEnd()
7824 
    iprot.readStructEnd()
7825 
 
7826 
  def write(self, oprot):
7827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7829 
      return
483 rajveer 7830 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 7831 
    if self.success is not None:
483 rajveer 7832 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7833 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7834 
      for iter90 in self.success:
7835 
        iter90.write(oprot)
483 rajveer 7836 
      oprot.writeListEnd()
94 ashish 7837 
      oprot.writeFieldEnd()
3431 rajveer 7838 
    if self.ex is not None:
94 ashish 7839 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7840 
      self.ex.write(oprot)
7841 
      oprot.writeFieldEnd()
7842 
    oprot.writeFieldStop()
7843 
    oprot.writeStructEnd()
7844 
 
3431 rajveer 7845 
  def validate(self):
7846 
    return
7847 
 
7848 
 
94 ashish 7849 
  def __repr__(self):
7850 
    L = ['%s=%r' % (key, value)
7851 
      for key, value in self.__dict__.iteritems()]
7852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7853 
 
7854 
  def __eq__(self, other):
7855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7856 
 
7857 
  def __ne__(self, other):
7858 
    return not (self == other)
7859 
 
4133 chandransh 7860 
class getOrdersInBatch_args:
7861 
  """
7862 
  Attributes:
7863 
   - statuses
7864 
   - offset
7865 
   - limit
7866 
   - warehouse_id
7867 
  """
7868 
 
7869 
  thrift_spec = (
7870 
    None, # 0
7871 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7872 
    (2, TType.I64, 'offset', None, None, ), # 2
7873 
    (3, TType.I64, 'limit', None, None, ), # 3
7874 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7875 
  )
7876 
 
7877 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
7878 
    self.statuses = statuses
7879 
    self.offset = offset
7880 
    self.limit = limit
7881 
    self.warehouse_id = warehouse_id
7882 
 
7883 
  def read(self, iprot):
7884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7886 
      return
7887 
    iprot.readStructBegin()
7888 
    while True:
7889 
      (fname, ftype, fid) = iprot.readFieldBegin()
7890 
      if ftype == TType.STOP:
7891 
        break
7892 
      if fid == 1:
7893 
        if ftype == TType.LIST:
7894 
          self.statuses = []
5031 varun.gupt 7895 
          (_etype94, _size91) = iprot.readListBegin()
7896 
          for _i95 in xrange(_size91):
7897 
            _elem96 = iprot.readI32();
7898 
            self.statuses.append(_elem96)
4133 chandransh 7899 
          iprot.readListEnd()
7900 
        else:
7901 
          iprot.skip(ftype)
7902 
      elif fid == 2:
7903 
        if ftype == TType.I64:
7904 
          self.offset = iprot.readI64();
7905 
        else:
7906 
          iprot.skip(ftype)
7907 
      elif fid == 3:
7908 
        if ftype == TType.I64:
7909 
          self.limit = iprot.readI64();
7910 
        else:
7911 
          iprot.skip(ftype)
7912 
      elif fid == 4:
7913 
        if ftype == TType.I64:
7914 
          self.warehouse_id = iprot.readI64();
7915 
        else:
7916 
          iprot.skip(ftype)
7917 
      else:
7918 
        iprot.skip(ftype)
7919 
      iprot.readFieldEnd()
7920 
    iprot.readStructEnd()
7921 
 
7922 
  def write(self, oprot):
7923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7925 
      return
7926 
    oprot.writeStructBegin('getOrdersInBatch_args')
7927 
    if self.statuses is not None:
7928 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7929 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7930 
      for iter97 in self.statuses:
7931 
        oprot.writeI32(iter97)
4133 chandransh 7932 
      oprot.writeListEnd()
7933 
      oprot.writeFieldEnd()
7934 
    if self.offset is not None:
7935 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7936 
      oprot.writeI64(self.offset)
7937 
      oprot.writeFieldEnd()
7938 
    if self.limit is not None:
7939 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7940 
      oprot.writeI64(self.limit)
7941 
      oprot.writeFieldEnd()
7942 
    if self.warehouse_id is not None:
7943 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7944 
      oprot.writeI64(self.warehouse_id)
7945 
      oprot.writeFieldEnd()
7946 
    oprot.writeFieldStop()
7947 
    oprot.writeStructEnd()
7948 
 
7949 
  def validate(self):
7950 
    return
7951 
 
7952 
 
7953 
  def __repr__(self):
7954 
    L = ['%s=%r' % (key, value)
7955 
      for key, value in self.__dict__.iteritems()]
7956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7957 
 
7958 
  def __eq__(self, other):
7959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7960 
 
7961 
  def __ne__(self, other):
7962 
    return not (self == other)
7963 
 
7964 
class getOrdersInBatch_result:
7965 
  """
7966 
  Attributes:
7967 
   - success
7968 
   - ex
7969 
  """
7970 
 
7971 
  thrift_spec = (
7972 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7973 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7974 
  )
7975 
 
7976 
  def __init__(self, success=None, ex=None,):
7977 
    self.success = success
7978 
    self.ex = ex
7979 
 
7980 
  def read(self, iprot):
7981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7983 
      return
7984 
    iprot.readStructBegin()
7985 
    while True:
7986 
      (fname, ftype, fid) = iprot.readFieldBegin()
7987 
      if ftype == TType.STOP:
7988 
        break
7989 
      if fid == 0:
7990 
        if ftype == TType.LIST:
7991 
          self.success = []
5031 varun.gupt 7992 
          (_etype101, _size98) = iprot.readListBegin()
7993 
          for _i102 in xrange(_size98):
7994 
            _elem103 = Order()
7995 
            _elem103.read(iprot)
7996 
            self.success.append(_elem103)
4133 chandransh 7997 
          iprot.readListEnd()
7998 
        else:
7999 
          iprot.skip(ftype)
8000 
      elif fid == 1:
8001 
        if ftype == TType.STRUCT:
8002 
          self.ex = TransactionServiceException()
8003 
          self.ex.read(iprot)
8004 
        else:
8005 
          iprot.skip(ftype)
8006 
      else:
8007 
        iprot.skip(ftype)
8008 
      iprot.readFieldEnd()
8009 
    iprot.readStructEnd()
8010 
 
8011 
  def write(self, oprot):
8012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8014 
      return
8015 
    oprot.writeStructBegin('getOrdersInBatch_result')
8016 
    if self.success is not None:
8017 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8018 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8019 
      for iter104 in self.success:
8020 
        iter104.write(oprot)
4133 chandransh 8021 
      oprot.writeListEnd()
8022 
      oprot.writeFieldEnd()
8023 
    if self.ex is not None:
8024 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8025 
      self.ex.write(oprot)
8026 
      oprot.writeFieldEnd()
8027 
    oprot.writeFieldStop()
8028 
    oprot.writeStructEnd()
8029 
 
8030 
  def validate(self):
8031 
    return
8032 
 
8033 
 
8034 
  def __repr__(self):
8035 
    L = ['%s=%r' % (key, value)
8036 
      for key, value in self.__dict__.iteritems()]
8037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8038 
 
8039 
  def __eq__(self, other):
8040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8041 
 
8042 
  def __ne__(self, other):
8043 
    return not (self == other)
8044 
 
8045 
class getOrderCount_args:
8046 
  """
8047 
  Attributes:
8048 
   - statuses
8049 
   - warehouseId
8050 
  """
8051 
 
8052 
  thrift_spec = (
8053 
    None, # 0
8054 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8055 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8056 
  )
8057 
 
8058 
  def __init__(self, statuses=None, warehouseId=None,):
8059 
    self.statuses = statuses
8060 
    self.warehouseId = warehouseId
8061 
 
8062 
  def read(self, iprot):
8063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8065 
      return
8066 
    iprot.readStructBegin()
8067 
    while True:
8068 
      (fname, ftype, fid) = iprot.readFieldBegin()
8069 
      if ftype == TType.STOP:
8070 
        break
8071 
      if fid == 1:
8072 
        if ftype == TType.LIST:
8073 
          self.statuses = []
5031 varun.gupt 8074 
          (_etype108, _size105) = iprot.readListBegin()
8075 
          for _i109 in xrange(_size105):
8076 
            _elem110 = iprot.readI32();
8077 
            self.statuses.append(_elem110)
4133 chandransh 8078 
          iprot.readListEnd()
8079 
        else:
8080 
          iprot.skip(ftype)
8081 
      elif fid == 2:
8082 
        if ftype == TType.I64:
8083 
          self.warehouseId = iprot.readI64();
8084 
        else:
8085 
          iprot.skip(ftype)
8086 
      else:
8087 
        iprot.skip(ftype)
8088 
      iprot.readFieldEnd()
8089 
    iprot.readStructEnd()
8090 
 
8091 
  def write(self, oprot):
8092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8094 
      return
8095 
    oprot.writeStructBegin('getOrderCount_args')
8096 
    if self.statuses is not None:
8097 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8098 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8099 
      for iter111 in self.statuses:
8100 
        oprot.writeI32(iter111)
4133 chandransh 8101 
      oprot.writeListEnd()
8102 
      oprot.writeFieldEnd()
8103 
    if self.warehouseId is not None:
8104 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8105 
      oprot.writeI64(self.warehouseId)
8106 
      oprot.writeFieldEnd()
8107 
    oprot.writeFieldStop()
8108 
    oprot.writeStructEnd()
8109 
 
8110 
  def validate(self):
8111 
    return
8112 
 
8113 
 
8114 
  def __repr__(self):
8115 
    L = ['%s=%r' % (key, value)
8116 
      for key, value in self.__dict__.iteritems()]
8117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8118 
 
8119 
  def __eq__(self, other):
8120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8121 
 
8122 
  def __ne__(self, other):
8123 
    return not (self == other)
8124 
 
8125 
class getOrderCount_result:
8126 
  """
8127 
  Attributes:
8128 
   - success
8129 
   - ex
8130 
  """
8131 
 
8132 
  thrift_spec = (
8133 
    (0, TType.I32, 'success', None, None, ), # 0
8134 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8135 
  )
8136 
 
8137 
  def __init__(self, success=None, ex=None,):
8138 
    self.success = success
8139 
    self.ex = ex
8140 
 
8141 
  def read(self, iprot):
8142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8144 
      return
8145 
    iprot.readStructBegin()
8146 
    while True:
8147 
      (fname, ftype, fid) = iprot.readFieldBegin()
8148 
      if ftype == TType.STOP:
8149 
        break
8150 
      if fid == 0:
8151 
        if ftype == TType.I32:
8152 
          self.success = iprot.readI32();
8153 
        else:
8154 
          iprot.skip(ftype)
8155 
      elif fid == 1:
8156 
        if ftype == TType.STRUCT:
8157 
          self.ex = TransactionServiceException()
8158 
          self.ex.read(iprot)
8159 
        else:
8160 
          iprot.skip(ftype)
8161 
      else:
8162 
        iprot.skip(ftype)
8163 
      iprot.readFieldEnd()
8164 
    iprot.readStructEnd()
8165 
 
8166 
  def write(self, oprot):
8167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8169 
      return
8170 
    oprot.writeStructBegin('getOrderCount_result')
8171 
    if self.success is not None:
8172 
      oprot.writeFieldBegin('success', TType.I32, 0)
8173 
      oprot.writeI32(self.success)
8174 
      oprot.writeFieldEnd()
8175 
    if self.ex is not None:
8176 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8177 
      self.ex.write(oprot)
8178 
      oprot.writeFieldEnd()
8179 
    oprot.writeFieldStop()
8180 
    oprot.writeStructEnd()
8181 
 
8182 
  def validate(self):
8183 
    return
8184 
 
8185 
 
8186 
  def __repr__(self):
8187 
    L = ['%s=%r' % (key, value)
8188 
      for key, value in self.__dict__.iteritems()]
8189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8190 
 
8191 
  def __eq__(self, other):
8192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8193 
 
8194 
  def __ne__(self, other):
8195 
    return not (self == other)
8196 
 
999 varun.gupt 8197 
class getOrdersByBillingDate_args:
8198 
  """
8199 
  Attributes:
8200 
   - status
8201 
   - start_billing_date
8202 
   - end_billing_date
8203 
   - warehouse_id
8204 
  """
8205 
 
8206 
  thrift_spec = (
8207 
    None, # 0
8208 
    (1, TType.I32, 'status', None, None, ), # 1
8209 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
8210 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
8211 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8212 
  )
8213 
 
8214 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
8215 
    self.status = status
8216 
    self.start_billing_date = start_billing_date
8217 
    self.end_billing_date = end_billing_date
8218 
    self.warehouse_id = warehouse_id
8219 
 
8220 
  def read(self, iprot):
8221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8223 
      return
8224 
    iprot.readStructBegin()
8225 
    while True:
8226 
      (fname, ftype, fid) = iprot.readFieldBegin()
8227 
      if ftype == TType.STOP:
8228 
        break
8229 
      if fid == 1:
8230 
        if ftype == TType.I32:
8231 
          self.status = iprot.readI32();
8232 
        else:
8233 
          iprot.skip(ftype)
8234 
      elif fid == 2:
8235 
        if ftype == TType.I64:
8236 
          self.start_billing_date = iprot.readI64();
8237 
        else:
8238 
          iprot.skip(ftype)
8239 
      elif fid == 3:
8240 
        if ftype == TType.I64:
8241 
          self.end_billing_date = iprot.readI64();
8242 
        else:
8243 
          iprot.skip(ftype)
8244 
      elif fid == 4:
8245 
        if ftype == TType.I64:
8246 
          self.warehouse_id = iprot.readI64();
8247 
        else:
8248 
          iprot.skip(ftype)
8249 
      else:
8250 
        iprot.skip(ftype)
8251 
      iprot.readFieldEnd()
8252 
    iprot.readStructEnd()
8253 
 
8254 
  def write(self, oprot):
8255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8257 
      return
8258 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 8259 
    if self.status is not None:
999 varun.gupt 8260 
      oprot.writeFieldBegin('status', TType.I32, 1)
8261 
      oprot.writeI32(self.status)
8262 
      oprot.writeFieldEnd()
3431 rajveer 8263 
    if self.start_billing_date is not None:
999 varun.gupt 8264 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
8265 
      oprot.writeI64(self.start_billing_date)
8266 
      oprot.writeFieldEnd()
3431 rajveer 8267 
    if self.end_billing_date is not None:
999 varun.gupt 8268 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
8269 
      oprot.writeI64(self.end_billing_date)
8270 
      oprot.writeFieldEnd()
3431 rajveer 8271 
    if self.warehouse_id is not None:
999 varun.gupt 8272 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8273 
      oprot.writeI64(self.warehouse_id)
8274 
      oprot.writeFieldEnd()
8275 
    oprot.writeFieldStop()
8276 
    oprot.writeStructEnd()
8277 
 
3431 rajveer 8278 
  def validate(self):
8279 
    return
8280 
 
8281 
 
999 varun.gupt 8282 
  def __repr__(self):
8283 
    L = ['%s=%r' % (key, value)
8284 
      for key, value in self.__dict__.iteritems()]
8285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8286 
 
8287 
  def __eq__(self, other):
8288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8289 
 
8290 
  def __ne__(self, other):
8291 
    return not (self == other)
8292 
 
8293 
class getOrdersByBillingDate_result:
8294 
  """
8295 
  Attributes:
8296 
   - success
8297 
   - ex
8298 
  """
8299 
 
8300 
  thrift_spec = (
8301 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8302 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8303 
  )
8304 
 
8305 
  def __init__(self, success=None, ex=None,):
8306 
    self.success = success
8307 
    self.ex = ex
8308 
 
8309 
  def read(self, iprot):
8310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8312 
      return
8313 
    iprot.readStructBegin()
8314 
    while True:
8315 
      (fname, ftype, fid) = iprot.readFieldBegin()
8316 
      if ftype == TType.STOP:
8317 
        break
8318 
      if fid == 0:
8319 
        if ftype == TType.LIST:
8320 
          self.success = []
5031 varun.gupt 8321 
          (_etype115, _size112) = iprot.readListBegin()
8322 
          for _i116 in xrange(_size112):
8323 
            _elem117 = Order()
8324 
            _elem117.read(iprot)
8325 
            self.success.append(_elem117)
999 varun.gupt 8326 
          iprot.readListEnd()
8327 
        else:
8328 
          iprot.skip(ftype)
8329 
      elif fid == 1:
8330 
        if ftype == TType.STRUCT:
8331 
          self.ex = TransactionServiceException()
8332 
          self.ex.read(iprot)
8333 
        else:
8334 
          iprot.skip(ftype)
8335 
      else:
8336 
        iprot.skip(ftype)
8337 
      iprot.readFieldEnd()
8338 
    iprot.readStructEnd()
8339 
 
8340 
  def write(self, oprot):
8341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8343 
      return
8344 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 8345 
    if self.success is not None:
999 varun.gupt 8346 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8347 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8348 
      for iter118 in self.success:
8349 
        iter118.write(oprot)
999 varun.gupt 8350 
      oprot.writeListEnd()
8351 
      oprot.writeFieldEnd()
3431 rajveer 8352 
    if self.ex is not None:
999 varun.gupt 8353 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8354 
      self.ex.write(oprot)
8355 
      oprot.writeFieldEnd()
8356 
    oprot.writeFieldStop()
8357 
    oprot.writeStructEnd()
8358 
 
3431 rajveer 8359 
  def validate(self):
8360 
    return
8361 
 
8362 
 
999 varun.gupt 8363 
  def __repr__(self):
8364 
    L = ['%s=%r' % (key, value)
8365 
      for key, value in self.__dict__.iteritems()]
8366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8367 
 
8368 
  def __eq__(self, other):
8369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8370 
 
8371 
  def __ne__(self, other):
8372 
    return not (self == other)
8373 
 
3427 chandransh 8374 
class getOrdersByShippingDate_args:
8375 
  """
8376 
  Attributes:
8377 
   - fromShippingDate
8378 
   - toShippingDate
8379 
   - providerId
8380 
   - warehouseId
3451 chandransh 8381 
   - cod
3427 chandransh 8382 
  """
8383 
 
8384 
  thrift_spec = (
8385 
    None, # 0
8386 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
8387 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
8388 
    (3, TType.I64, 'providerId', None, None, ), # 3
8389 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 8390 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 8391 
  )
8392 
 
3451 chandransh 8393 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 8394 
    self.fromShippingDate = fromShippingDate
8395 
    self.toShippingDate = toShippingDate
8396 
    self.providerId = providerId
8397 
    self.warehouseId = warehouseId
3451 chandransh 8398 
    self.cod = cod
3427 chandransh 8399 
 
8400 
  def read(self, iprot):
8401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8403 
      return
8404 
    iprot.readStructBegin()
8405 
    while True:
8406 
      (fname, ftype, fid) = iprot.readFieldBegin()
8407 
      if ftype == TType.STOP:
8408 
        break
8409 
      if fid == 1:
8410 
        if ftype == TType.I64:
8411 
          self.fromShippingDate = iprot.readI64();
8412 
        else:
8413 
          iprot.skip(ftype)
8414 
      elif fid == 2:
8415 
        if ftype == TType.I64:
8416 
          self.toShippingDate = iprot.readI64();
8417 
        else:
8418 
          iprot.skip(ftype)
8419 
      elif fid == 3:
8420 
        if ftype == TType.I64:
8421 
          self.providerId = iprot.readI64();
8422 
        else:
8423 
          iprot.skip(ftype)
8424 
      elif fid == 4:
8425 
        if ftype == TType.I64:
8426 
          self.warehouseId = iprot.readI64();
8427 
        else:
8428 
          iprot.skip(ftype)
3451 chandransh 8429 
      elif fid == 5:
8430 
        if ftype == TType.BOOL:
8431 
          self.cod = iprot.readBool();
8432 
        else:
8433 
          iprot.skip(ftype)
3427 chandransh 8434 
      else:
8435 
        iprot.skip(ftype)
8436 
      iprot.readFieldEnd()
8437 
    iprot.readStructEnd()
8438 
 
8439 
  def write(self, oprot):
8440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8442 
      return
8443 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 8444 
    if self.fromShippingDate is not None:
3427 chandransh 8445 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
8446 
      oprot.writeI64(self.fromShippingDate)
8447 
      oprot.writeFieldEnd()
3431 rajveer 8448 
    if self.toShippingDate is not None:
3427 chandransh 8449 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
8450 
      oprot.writeI64(self.toShippingDate)
8451 
      oprot.writeFieldEnd()
3431 rajveer 8452 
    if self.providerId is not None:
3427 chandransh 8453 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
8454 
      oprot.writeI64(self.providerId)
8455 
      oprot.writeFieldEnd()
3431 rajveer 8456 
    if self.warehouseId is not None:
3427 chandransh 8457 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
8458 
      oprot.writeI64(self.warehouseId)
8459 
      oprot.writeFieldEnd()
3451 chandransh 8460 
    if self.cod is not None:
8461 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
8462 
      oprot.writeBool(self.cod)
8463 
      oprot.writeFieldEnd()
3427 chandransh 8464 
    oprot.writeFieldStop()
8465 
    oprot.writeStructEnd()
8466 
 
3431 rajveer 8467 
  def validate(self):
8468 
    return
8469 
 
8470 
 
3427 chandransh 8471 
  def __repr__(self):
8472 
    L = ['%s=%r' % (key, value)
8473 
      for key, value in self.__dict__.iteritems()]
8474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8475 
 
8476 
  def __eq__(self, other):
8477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8478 
 
8479 
  def __ne__(self, other):
8480 
    return not (self == other)
8481 
 
8482 
class getOrdersByShippingDate_result:
8483 
  """
8484 
  Attributes:
8485 
   - success
8486 
   - ex
8487 
  """
8488 
 
8489 
  thrift_spec = (
8490 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8491 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8492 
  )
8493 
 
8494 
  def __init__(self, success=None, ex=None,):
8495 
    self.success = success
8496 
    self.ex = ex
8497 
 
8498 
  def read(self, iprot):
8499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8501 
      return
8502 
    iprot.readStructBegin()
8503 
    while True:
8504 
      (fname, ftype, fid) = iprot.readFieldBegin()
8505 
      if ftype == TType.STOP:
8506 
        break
8507 
      if fid == 0:
8508 
        if ftype == TType.LIST:
8509 
          self.success = []
5031 varun.gupt 8510 
          (_etype122, _size119) = iprot.readListBegin()
8511 
          for _i123 in xrange(_size119):
8512 
            _elem124 = Order()
8513 
            _elem124.read(iprot)
8514 
            self.success.append(_elem124)
3427 chandransh 8515 
          iprot.readListEnd()
8516 
        else:
8517 
          iprot.skip(ftype)
8518 
      elif fid == 1:
8519 
        if ftype == TType.STRUCT:
8520 
          self.ex = TransactionServiceException()
8521 
          self.ex.read(iprot)
8522 
        else:
8523 
          iprot.skip(ftype)
8524 
      else:
8525 
        iprot.skip(ftype)
8526 
      iprot.readFieldEnd()
8527 
    iprot.readStructEnd()
8528 
 
8529 
  def write(self, oprot):
8530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8532 
      return
8533 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 8534 
    if self.success is not None:
3427 chandransh 8535 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8536 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8537 
      for iter125 in self.success:
8538 
        iter125.write(oprot)
3427 chandransh 8539 
      oprot.writeListEnd()
8540 
      oprot.writeFieldEnd()
3431 rajveer 8541 
    if self.ex is not None:
3427 chandransh 8542 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8543 
      self.ex.write(oprot)
8544 
      oprot.writeFieldEnd()
8545 
    oprot.writeFieldStop()
8546 
    oprot.writeStructEnd()
8547 
 
3431 rajveer 8548 
  def validate(self):
8549 
    return
8550 
 
8551 
 
3427 chandransh 8552 
  def __repr__(self):
8553 
    L = ['%s=%r' % (key, value)
8554 
      for key, value in self.__dict__.iteritems()]
8555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8556 
 
8557 
  def __eq__(self, other):
8558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8559 
 
8560 
  def __ne__(self, other):
8561 
    return not (self == other)
8562 
 
1382 varun.gupt 8563 
class getReturnableOrdersForCustomer_args:
8564 
  """
8565 
  Attributes:
8566 
   - customer_id
8567 
   - limit
8568 
  """
8569 
 
8570 
  thrift_spec = (
8571 
    None, # 0
8572 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8573 
    (2, TType.I64, 'limit', None, None, ), # 2
8574 
  )
8575 
 
8576 
  def __init__(self, customer_id=None, limit=None,):
8577 
    self.customer_id = customer_id
8578 
    self.limit = limit
8579 
 
8580 
  def read(self, iprot):
8581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8583 
      return
8584 
    iprot.readStructBegin()
8585 
    while True:
8586 
      (fname, ftype, fid) = iprot.readFieldBegin()
8587 
      if ftype == TType.STOP:
8588 
        break
8589 
      if fid == 1:
8590 
        if ftype == TType.I64:
8591 
          self.customer_id = iprot.readI64();
8592 
        else:
8593 
          iprot.skip(ftype)
8594 
      elif fid == 2:
8595 
        if ftype == TType.I64:
8596 
          self.limit = iprot.readI64();
8597 
        else:
8598 
          iprot.skip(ftype)
8599 
      else:
8600 
        iprot.skip(ftype)
8601 
      iprot.readFieldEnd()
8602 
    iprot.readStructEnd()
8603 
 
8604 
  def write(self, oprot):
8605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8607 
      return
8608 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 8609 
    if self.customer_id is not None:
1382 varun.gupt 8610 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8611 
      oprot.writeI64(self.customer_id)
8612 
      oprot.writeFieldEnd()
3431 rajveer 8613 
    if self.limit is not None:
1382 varun.gupt 8614 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8615 
      oprot.writeI64(self.limit)
8616 
      oprot.writeFieldEnd()
8617 
    oprot.writeFieldStop()
8618 
    oprot.writeStructEnd()
8619 
 
3431 rajveer 8620 
  def validate(self):
8621 
    return
8622 
 
8623 
 
1382 varun.gupt 8624 
  def __repr__(self):
8625 
    L = ['%s=%r' % (key, value)
8626 
      for key, value in self.__dict__.iteritems()]
8627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8628 
 
8629 
  def __eq__(self, other):
8630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8631 
 
8632 
  def __ne__(self, other):
8633 
    return not (self == other)
8634 
 
8635 
class getReturnableOrdersForCustomer_result:
8636 
  """
8637 
  Attributes:
8638 
   - success
8639 
   - ex
8640 
  """
8641 
 
8642 
  thrift_spec = (
8643 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8644 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8645 
  )
8646 
 
8647 
  def __init__(self, success=None, ex=None,):
8648 
    self.success = success
8649 
    self.ex = ex
8650 
 
8651 
  def read(self, iprot):
8652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8654 
      return
8655 
    iprot.readStructBegin()
8656 
    while True:
8657 
      (fname, ftype, fid) = iprot.readFieldBegin()
8658 
      if ftype == TType.STOP:
8659 
        break
8660 
      if fid == 0:
8661 
        if ftype == TType.LIST:
8662 
          self.success = []
5031 varun.gupt 8663 
          (_etype129, _size126) = iprot.readListBegin()
8664 
          for _i130 in xrange(_size126):
8665 
            _elem131 = iprot.readI64();
8666 
            self.success.append(_elem131)
1382 varun.gupt 8667 
          iprot.readListEnd()
8668 
        else:
8669 
          iprot.skip(ftype)
8670 
      elif fid == 1:
8671 
        if ftype == TType.STRUCT:
8672 
          self.ex = TransactionServiceException()
8673 
          self.ex.read(iprot)
8674 
        else:
8675 
          iprot.skip(ftype)
8676 
      else:
8677 
        iprot.skip(ftype)
8678 
      iprot.readFieldEnd()
8679 
    iprot.readStructEnd()
8680 
 
8681 
  def write(self, oprot):
8682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8684 
      return
8685 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 8686 
    if self.success is not None:
1382 varun.gupt 8687 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8688 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8689 
      for iter132 in self.success:
8690 
        oprot.writeI64(iter132)
1382 varun.gupt 8691 
      oprot.writeListEnd()
8692 
      oprot.writeFieldEnd()
3431 rajveer 8693 
    if self.ex is not None:
1382 varun.gupt 8694 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8695 
      self.ex.write(oprot)
8696 
      oprot.writeFieldEnd()
8697 
    oprot.writeFieldStop()
8698 
    oprot.writeStructEnd()
8699 
 
3431 rajveer 8700 
  def validate(self):
8701 
    return
8702 
 
8703 
 
1382 varun.gupt 8704 
  def __repr__(self):
8705 
    L = ['%s=%r' % (key, value)
8706 
      for key, value in self.__dict__.iteritems()]
8707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8708 
 
8709 
  def __eq__(self, other):
8710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8711 
 
8712 
  def __ne__(self, other):
8713 
    return not (self == other)
8714 
 
8715 
class getCancellableOrdersForCustomer_args:
8716 
  """
8717 
  Attributes:
8718 
   - customer_id
8719 
   - limit
8720 
  """
8721 
 
8722 
  thrift_spec = (
8723 
    None, # 0
8724 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8725 
    (2, TType.I64, 'limit', None, None, ), # 2
8726 
  )
8727 
 
8728 
  def __init__(self, customer_id=None, limit=None,):
8729 
    self.customer_id = customer_id
8730 
    self.limit = limit
8731 
 
8732 
  def read(self, iprot):
8733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8735 
      return
8736 
    iprot.readStructBegin()
8737 
    while True:
8738 
      (fname, ftype, fid) = iprot.readFieldBegin()
8739 
      if ftype == TType.STOP:
8740 
        break
8741 
      if fid == 1:
8742 
        if ftype == TType.I64:
8743 
          self.customer_id = iprot.readI64();
8744 
        else:
8745 
          iprot.skip(ftype)
8746 
      elif fid == 2:
8747 
        if ftype == TType.I64:
8748 
          self.limit = iprot.readI64();
8749 
        else:
8750 
          iprot.skip(ftype)
8751 
      else:
8752 
        iprot.skip(ftype)
8753 
      iprot.readFieldEnd()
8754 
    iprot.readStructEnd()
8755 
 
8756 
  def write(self, oprot):
8757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8759 
      return
8760 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 8761 
    if self.customer_id is not None:
1382 varun.gupt 8762 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8763 
      oprot.writeI64(self.customer_id)
8764 
      oprot.writeFieldEnd()
3431 rajveer 8765 
    if self.limit is not None:
1382 varun.gupt 8766 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8767 
      oprot.writeI64(self.limit)
8768 
      oprot.writeFieldEnd()
8769 
    oprot.writeFieldStop()
8770 
    oprot.writeStructEnd()
8771 
 
3431 rajveer 8772 
  def validate(self):
8773 
    return
8774 
 
8775 
 
1382 varun.gupt 8776 
  def __repr__(self):
8777 
    L = ['%s=%r' % (key, value)
8778 
      for key, value in self.__dict__.iteritems()]
8779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8780 
 
8781 
  def __eq__(self, other):
8782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8783 
 
8784 
  def __ne__(self, other):
8785 
    return not (self == other)
8786 
 
8787 
class getCancellableOrdersForCustomer_result:
8788 
  """
8789 
  Attributes:
8790 
   - success
8791 
   - ex
8792 
  """
8793 
 
8794 
  thrift_spec = (
8795 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8796 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8797 
  )
8798 
 
8799 
  def __init__(self, success=None, ex=None,):
8800 
    self.success = success
8801 
    self.ex = ex
8802 
 
8803 
  def read(self, iprot):
8804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8806 
      return
8807 
    iprot.readStructBegin()
8808 
    while True:
8809 
      (fname, ftype, fid) = iprot.readFieldBegin()
8810 
      if ftype == TType.STOP:
8811 
        break
8812 
      if fid == 0:
8813 
        if ftype == TType.LIST:
8814 
          self.success = []
5031 varun.gupt 8815 
          (_etype136, _size133) = iprot.readListBegin()
8816 
          for _i137 in xrange(_size133):
8817 
            _elem138 = iprot.readI64();
8818 
            self.success.append(_elem138)
1382 varun.gupt 8819 
          iprot.readListEnd()
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
8837 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 8838 
    if self.success is not None:
1382 varun.gupt 8839 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8840 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8841 
      for iter139 in self.success:
8842 
        oprot.writeI64(iter139)
1382 varun.gupt 8843 
      oprot.writeListEnd()
8844 
      oprot.writeFieldEnd()
3431 rajveer 8845 
    if self.ex is not None:
1382 varun.gupt 8846 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8847 
      self.ex.write(oprot)
8848 
      oprot.writeFieldEnd()
8849 
    oprot.writeFieldStop()
8850 
    oprot.writeStructEnd()
8851 
 
3431 rajveer 8852 
  def validate(self):
8853 
    return
8854 
 
8855 
 
1382 varun.gupt 8856 
  def __repr__(self):
8857 
    L = ['%s=%r' % (key, value)
8858 
      for key, value in self.__dict__.iteritems()]
8859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8860 
 
8861 
  def __eq__(self, other):
8862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8863 
 
8864 
  def __ne__(self, other):
8865 
    return not (self == other)
8866 
 
483 rajveer 8867 
class changeOrderStatus_args:
94 ashish 8868 
  """
8869 
  Attributes:
483 rajveer 8870 
   - orderId
8871 
   - status
8872 
   - description
94 ashish 8873 
  """
8874 
 
8875 
  thrift_spec = (
8876 
    None, # 0
483 rajveer 8877 
    (1, TType.I64, 'orderId', None, None, ), # 1
8878 
    (2, TType.I32, 'status', None, None, ), # 2
8879 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8880 
  )
8881 
 
483 rajveer 8882 
  def __init__(self, orderId=None, status=None, description=None,):
8883 
    self.orderId = orderId
8884 
    self.status = status
8885 
    self.description = description
94 ashish 8886 
 
8887 
  def read(self, iprot):
8888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8890 
      return
8891 
    iprot.readStructBegin()
8892 
    while True:
8893 
      (fname, ftype, fid) = iprot.readFieldBegin()
8894 
      if ftype == TType.STOP:
8895 
        break
8896 
      if fid == 1:
8897 
        if ftype == TType.I64:
483 rajveer 8898 
          self.orderId = iprot.readI64();
94 ashish 8899 
        else:
8900 
          iprot.skip(ftype)
8901 
      elif fid == 2:
483 rajveer 8902 
        if ftype == TType.I32:
8903 
          self.status = iprot.readI32();
94 ashish 8904 
        else:
8905 
          iprot.skip(ftype)
483 rajveer 8906 
      elif fid == 3:
8907 
        if ftype == TType.STRING:
8908 
          self.description = iprot.readString();
8909 
        else:
8910 
          iprot.skip(ftype)
94 ashish 8911 
      else:
8912 
        iprot.skip(ftype)
8913 
      iprot.readFieldEnd()
8914 
    iprot.readStructEnd()
8915 
 
8916 
  def write(self, oprot):
8917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8919 
      return
483 rajveer 8920 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 8921 
    if self.orderId is not None:
483 rajveer 8922 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8923 
      oprot.writeI64(self.orderId)
94 ashish 8924 
      oprot.writeFieldEnd()
3431 rajveer 8925 
    if self.status is not None:
483 rajveer 8926 
      oprot.writeFieldBegin('status', TType.I32, 2)
8927 
      oprot.writeI32(self.status)
94 ashish 8928 
      oprot.writeFieldEnd()
3431 rajveer 8929 
    if self.description is not None:
483 rajveer 8930 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8931 
      oprot.writeString(self.description)
8932 
      oprot.writeFieldEnd()
94 ashish 8933 
    oprot.writeFieldStop()
8934 
    oprot.writeStructEnd()
8935 
 
3431 rajveer 8936 
  def validate(self):
8937 
    return
8938 
 
8939 
 
94 ashish 8940 
  def __repr__(self):
8941 
    L = ['%s=%r' % (key, value)
8942 
      for key, value in self.__dict__.iteritems()]
8943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8944 
 
8945 
  def __eq__(self, other):
8946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8947 
 
8948 
  def __ne__(self, other):
8949 
    return not (self == other)
8950 
 
483 rajveer 8951 
class changeOrderStatus_result:
94 ashish 8952 
  """
8953 
  Attributes:
8954 
   - success
8955 
   - ex
8956 
  """
8957 
 
8958 
  thrift_spec = (
8959 
    (0, TType.BOOL, 'success', None, None, ), # 0
8960 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8961 
  )
8962 
 
8963 
  def __init__(self, success=None, ex=None,):
8964 
    self.success = success
8965 
    self.ex = ex
8966 
 
8967 
  def read(self, iprot):
8968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8970 
      return
8971 
    iprot.readStructBegin()
8972 
    while True:
8973 
      (fname, ftype, fid) = iprot.readFieldBegin()
8974 
      if ftype == TType.STOP:
8975 
        break
8976 
      if fid == 0:
8977 
        if ftype == TType.BOOL:
8978 
          self.success = iprot.readBool();
8979 
        else:
8980 
          iprot.skip(ftype)
8981 
      elif fid == 1:
8982 
        if ftype == TType.STRUCT:
8983 
          self.ex = TransactionServiceException()
8984 
          self.ex.read(iprot)
8985 
        else:
8986 
          iprot.skip(ftype)
8987 
      else:
8988 
        iprot.skip(ftype)
8989 
      iprot.readFieldEnd()
8990 
    iprot.readStructEnd()
8991 
 
8992 
  def write(self, oprot):
8993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8995 
      return
483 rajveer 8996 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 8997 
    if self.success is not None:
94 ashish 8998 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8999 
      oprot.writeBool(self.success)
9000 
      oprot.writeFieldEnd()
3431 rajveer 9001 
    if self.ex is not None:
94 ashish 9002 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9003 
      self.ex.write(oprot)
9004 
      oprot.writeFieldEnd()
9005 
    oprot.writeFieldStop()
9006 
    oprot.writeStructEnd()
9007 
 
3431 rajveer 9008 
  def validate(self):
9009 
    return
9010 
 
9011 
 
94 ashish 9012 
  def __repr__(self):
9013 
    L = ['%s=%r' % (key, value)
9014 
      for key, value in self.__dict__.iteritems()]
9015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9016 
 
9017 
  def __eq__(self, other):
9018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9019 
 
9020 
  def __ne__(self, other):
9021 
    return not (self == other)
9022 
 
3064 chandransh 9023 
class getOrdersForTransaction_args:
494 rajveer 9024 
  """
9025 
  Attributes:
3064 chandransh 9026 
   - transactionId
9027 
   - customerId
494 rajveer 9028 
  """
9029 
 
9030 
  thrift_spec = (
9031 
    None, # 0
3064 chandransh 9032 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9033 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 9034 
  )
9035 
 
3064 chandransh 9036 
  def __init__(self, transactionId=None, customerId=None,):
9037 
    self.transactionId = transactionId
9038 
    self.customerId = customerId
494 rajveer 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.transactionId = iprot.readI64();
494 rajveer 9052 
        else:
9053 
          iprot.skip(ftype)
9054 
      elif fid == 2:
3064 chandransh 9055 
        if ftype == TType.I64:
9056 
          self.customerId = iprot.readI64();
494 rajveer 9057 
        else:
9058 
          iprot.skip(ftype)
9059 
      else:
9060 
        iprot.skip(ftype)
9061 
      iprot.readFieldEnd()
9062 
    iprot.readStructEnd()
9063 
 
9064 
  def write(self, oprot):
9065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9067 
      return
3064 chandransh 9068 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 9069 
    if self.transactionId is not None:
3064 chandransh 9070 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9071 
      oprot.writeI64(self.transactionId)
494 rajveer 9072 
      oprot.writeFieldEnd()
3431 rajveer 9073 
    if self.customerId is not None:
3064 chandransh 9074 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
9075 
      oprot.writeI64(self.customerId)
494 rajveer 9076 
      oprot.writeFieldEnd()
9077 
    oprot.writeFieldStop()
9078 
    oprot.writeStructEnd()
9079 
 
3431 rajveer 9080 
  def validate(self):
9081 
    return
9082 
 
9083 
 
494 rajveer 9084 
  def __repr__(self):
9085 
    L = ['%s=%r' % (key, value)
9086 
      for key, value in self.__dict__.iteritems()]
9087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9088 
 
9089 
  def __eq__(self, other):
9090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9091 
 
9092 
  def __ne__(self, other):
9093 
    return not (self == other)
9094 
 
3064 chandransh 9095 
class getOrdersForTransaction_result:
494 rajveer 9096 
  """
9097 
  Attributes:
9098 
   - success
9099 
   - ex
9100 
  """
9101 
 
9102 
  thrift_spec = (
3064 chandransh 9103 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 9104 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9105 
  )
9106 
 
9107 
  def __init__(self, success=None, ex=None,):
9108 
    self.success = success
9109 
    self.ex = ex
9110 
 
9111 
  def read(self, iprot):
9112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9114 
      return
9115 
    iprot.readStructBegin()
9116 
    while True:
9117 
      (fname, ftype, fid) = iprot.readFieldBegin()
9118 
      if ftype == TType.STOP:
9119 
        break
9120 
      if fid == 0:
3064 chandransh 9121 
        if ftype == TType.LIST:
9122 
          self.success = []
5031 varun.gupt 9123 
          (_etype143, _size140) = iprot.readListBegin()
9124 
          for _i144 in xrange(_size140):
9125 
            _elem145 = Order()
9126 
            _elem145.read(iprot)
9127 
            self.success.append(_elem145)
3064 chandransh 9128 
          iprot.readListEnd()
494 rajveer 9129 
        else:
9130 
          iprot.skip(ftype)
9131 
      elif fid == 1:
9132 
        if ftype == TType.STRUCT:
9133 
          self.ex = TransactionServiceException()
9134 
          self.ex.read(iprot)
9135 
        else:
9136 
          iprot.skip(ftype)
9137 
      else:
9138 
        iprot.skip(ftype)
9139 
      iprot.readFieldEnd()
9140 
    iprot.readStructEnd()
9141 
 
9142 
  def write(self, oprot):
9143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9145 
      return
3064 chandransh 9146 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 9147 
    if self.success is not None:
3064 chandransh 9148 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9149 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9150 
      for iter146 in self.success:
9151 
        iter146.write(oprot)
3064 chandransh 9152 
      oprot.writeListEnd()
494 rajveer 9153 
      oprot.writeFieldEnd()
3431 rajveer 9154 
    if self.ex is not None:
494 rajveer 9155 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9156 
      self.ex.write(oprot)
9157 
      oprot.writeFieldEnd()
9158 
    oprot.writeFieldStop()
9159 
    oprot.writeStructEnd()
9160 
 
3431 rajveer 9161 
  def validate(self):
9162 
    return
9163 
 
9164 
 
494 rajveer 9165 
  def __repr__(self):
9166 
    L = ['%s=%r' % (key, value)
9167 
      for key, value in self.__dict__.iteritems()]
9168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9169 
 
9170 
  def __eq__(self, other):
9171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9172 
 
9173 
  def __ne__(self, other):
9174 
    return not (self == other)
9175 
 
3064 chandransh 9176 
class getOrdersForCustomer_args:
1149 chandransh 9177 
  """
9178 
  Attributes:
3064 chandransh 9179 
   - customerId
9180 
   - from_date
9181 
   - to_date
9182 
   - statuses
1149 chandransh 9183 
  """
9184 
 
9185 
  thrift_spec = (
9186 
    None, # 0
3064 chandransh 9187 
    (1, TType.I64, 'customerId', None, None, ), # 1
9188 
    (2, TType.I64, 'from_date', None, None, ), # 2
9189 
    (3, TType.I64, 'to_date', None, None, ), # 3
9190 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 9191 
  )
9192 
 
3064 chandransh 9193 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
9194 
    self.customerId = customerId
9195 
    self.from_date = from_date
9196 
    self.to_date = to_date
9197 
    self.statuses = statuses
1149 chandransh 9198 
 
9199 
  def read(self, iprot):
9200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9202 
      return
9203 
    iprot.readStructBegin()
9204 
    while True:
9205 
      (fname, ftype, fid) = iprot.readFieldBegin()
9206 
      if ftype == TType.STOP:
9207 
        break
9208 
      if fid == 1:
9209 
        if ftype == TType.I64:
3064 chandransh 9210 
          self.customerId = iprot.readI64();
1149 chandransh 9211 
        else:
9212 
          iprot.skip(ftype)
9213 
      elif fid == 2:
9214 
        if ftype == TType.I64:
3064 chandransh 9215 
          self.from_date = iprot.readI64();
1149 chandransh 9216 
        else:
9217 
          iprot.skip(ftype)
2783 chandransh 9218 
      elif fid == 3:
9219 
        if ftype == TType.I64:
3064 chandransh 9220 
          self.to_date = iprot.readI64();
2783 chandransh 9221 
        else:
9222 
          iprot.skip(ftype)
9223 
      elif fid == 4:
3064 chandransh 9224 
        if ftype == TType.LIST:
9225 
          self.statuses = []
5031 varun.gupt 9226 
          (_etype150, _size147) = iprot.readListBegin()
9227 
          for _i151 in xrange(_size147):
9228 
            _elem152 = iprot.readI32();
9229 
            self.statuses.append(_elem152)
3064 chandransh 9230 
          iprot.readListEnd()
2783 chandransh 9231 
        else:
9232 
          iprot.skip(ftype)
1149 chandransh 9233 
      else:
9234 
        iprot.skip(ftype)
9235 
      iprot.readFieldEnd()
9236 
    iprot.readStructEnd()
9237 
 
9238 
  def write(self, oprot):
9239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9241 
      return
3064 chandransh 9242 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 9243 
    if self.customerId is not None:
3064 chandransh 9244 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9245 
      oprot.writeI64(self.customerId)
1149 chandransh 9246 
      oprot.writeFieldEnd()
3431 rajveer 9247 
    if self.from_date is not None:
3064 chandransh 9248 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9249 
      oprot.writeI64(self.from_date)
1149 chandransh 9250 
      oprot.writeFieldEnd()
3431 rajveer 9251 
    if self.to_date is not None:
3064 chandransh 9252 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9253 
      oprot.writeI64(self.to_date)
2783 chandransh 9254 
      oprot.writeFieldEnd()
3431 rajveer 9255 
    if self.statuses is not None:
3064 chandransh 9256 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
9257 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 9258 
      for iter153 in self.statuses:
9259 
        oprot.writeI32(iter153)
3064 chandransh 9260 
      oprot.writeListEnd()
2783 chandransh 9261 
      oprot.writeFieldEnd()
1149 chandransh 9262 
    oprot.writeFieldStop()
9263 
    oprot.writeStructEnd()
9264 
 
3431 rajveer 9265 
  def validate(self):
9266 
    return
9267 
 
9268 
 
1149 chandransh 9269 
  def __repr__(self):
9270 
    L = ['%s=%r' % (key, value)
9271 
      for key, value in self.__dict__.iteritems()]
9272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9273 
 
9274 
  def __eq__(self, other):
9275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9276 
 
9277 
  def __ne__(self, other):
9278 
    return not (self == other)
9279 
 
3064 chandransh 9280 
class getOrdersForCustomer_result:
1149 chandransh 9281 
  """
9282 
  Attributes:
9283 
   - success
9284 
   - ex
9285 
  """
9286 
 
9287 
  thrift_spec = (
3064 chandransh 9288 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 9289 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9290 
  )
9291 
 
9292 
  def __init__(self, success=None, ex=None,):
9293 
    self.success = success
9294 
    self.ex = ex
9295 
 
9296 
  def read(self, iprot):
9297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9299 
      return
9300 
    iprot.readStructBegin()
9301 
    while True:
9302 
      (fname, ftype, fid) = iprot.readFieldBegin()
9303 
      if ftype == TType.STOP:
9304 
        break
9305 
      if fid == 0:
3064 chandransh 9306 
        if ftype == TType.LIST:
9307 
          self.success = []
5031 varun.gupt 9308 
          (_etype157, _size154) = iprot.readListBegin()
9309 
          for _i158 in xrange(_size154):
9310 
            _elem159 = Order()
9311 
            _elem159.read(iprot)
9312 
            self.success.append(_elem159)
3064 chandransh 9313 
          iprot.readListEnd()
1149 chandransh 9314 
        else:
9315 
          iprot.skip(ftype)
9316 
      elif fid == 1:
9317 
        if ftype == TType.STRUCT:
9318 
          self.ex = TransactionServiceException()
9319 
          self.ex.read(iprot)
9320 
        else:
9321 
          iprot.skip(ftype)
9322 
      else:
9323 
        iprot.skip(ftype)
9324 
      iprot.readFieldEnd()
9325 
    iprot.readStructEnd()
9326 
 
9327 
  def write(self, oprot):
9328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9330 
      return
3064 chandransh 9331 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 9332 
    if self.success is not None:
3064 chandransh 9333 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9334 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9335 
      for iter160 in self.success:
9336 
        iter160.write(oprot)
3064 chandransh 9337 
      oprot.writeListEnd()
1149 chandransh 9338 
      oprot.writeFieldEnd()
3431 rajveer 9339 
    if self.ex is not None:
1149 chandransh 9340 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9341 
      self.ex.write(oprot)
9342 
      oprot.writeFieldEnd()
9343 
    oprot.writeFieldStop()
9344 
    oprot.writeStructEnd()
9345 
 
3431 rajveer 9346 
  def validate(self):
9347 
    return
9348 
 
9349 
 
1149 chandransh 9350 
  def __repr__(self):
9351 
    L = ['%s=%r' % (key, value)
9352 
      for key, value in self.__dict__.iteritems()]
9353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9354 
 
9355 
  def __eq__(self, other):
9356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9357 
 
9358 
  def __ne__(self, other):
9359 
    return not (self == other)
9360 
 
3064 chandransh 9361 
class createOrder_args:
921 rajveer 9362 
  """
9363 
  Attributes:
3064 chandransh 9364 
   - order
921 rajveer 9365 
  """
9366 
 
9367 
  thrift_spec = (
9368 
    None, # 0
3064 chandransh 9369 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 9370 
  )
9371 
 
3064 chandransh 9372 
  def __init__(self, order=None,):
9373 
    self.order = order
921 rajveer 9374 
 
9375 
  def read(self, iprot):
9376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9378 
      return
9379 
    iprot.readStructBegin()
9380 
    while True:
9381 
      (fname, ftype, fid) = iprot.readFieldBegin()
9382 
      if ftype == TType.STOP:
9383 
        break
9384 
      if fid == 1:
3064 chandransh 9385 
        if ftype == TType.STRUCT:
9386 
          self.order = Order()
9387 
          self.order.read(iprot)
921 rajveer 9388 
        else:
9389 
          iprot.skip(ftype)
9390 
      else:
9391 
        iprot.skip(ftype)
9392 
      iprot.readFieldEnd()
9393 
    iprot.readStructEnd()
9394 
 
9395 
  def write(self, oprot):
9396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9398 
      return
3064 chandransh 9399 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 9400 
    if self.order is not None:
3064 chandransh 9401 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
9402 
      self.order.write(oprot)
921 rajveer 9403 
      oprot.writeFieldEnd()
9404 
    oprot.writeFieldStop()
9405 
    oprot.writeStructEnd()
9406 
 
3431 rajveer 9407 
  def validate(self):
9408 
    return
9409 
 
9410 
 
921 rajveer 9411 
  def __repr__(self):
9412 
    L = ['%s=%r' % (key, value)
9413 
      for key, value in self.__dict__.iteritems()]
9414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9415 
 
9416 
  def __eq__(self, other):
9417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9418 
 
9419 
  def __ne__(self, other):
9420 
    return not (self == other)
9421 
 
3064 chandransh 9422 
class createOrder_result:
921 rajveer 9423 
  """
9424 
  Attributes:
9425 
   - success
9426 
   - ex
9427 
  """
9428 
 
9429 
  thrift_spec = (
3064 chandransh 9430 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 9431 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9432 
  )
9433 
 
9434 
  def __init__(self, success=None, ex=None,):
9435 
    self.success = success
9436 
    self.ex = ex
9437 
 
9438 
  def read(self, iprot):
9439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9441 
      return
9442 
    iprot.readStructBegin()
9443 
    while True:
9444 
      (fname, ftype, fid) = iprot.readFieldBegin()
9445 
      if ftype == TType.STOP:
9446 
        break
9447 
      if fid == 0:
3064 chandransh 9448 
        if ftype == TType.I64:
9449 
          self.success = iprot.readI64();
921 rajveer 9450 
        else:
9451 
          iprot.skip(ftype)
9452 
      elif fid == 1:
9453 
        if ftype == TType.STRUCT:
9454 
          self.ex = TransactionServiceException()
9455 
          self.ex.read(iprot)
9456 
        else:
9457 
          iprot.skip(ftype)
9458 
      else:
9459 
        iprot.skip(ftype)
9460 
      iprot.readFieldEnd()
9461 
    iprot.readStructEnd()
9462 
 
9463 
  def write(self, oprot):
9464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9466 
      return
3064 chandransh 9467 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 9468 
    if self.success is not None:
3064 chandransh 9469 
      oprot.writeFieldBegin('success', TType.I64, 0)
9470 
      oprot.writeI64(self.success)
921 rajveer 9471 
      oprot.writeFieldEnd()
3431 rajveer 9472 
    if self.ex is not None:
921 rajveer 9473 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9474 
      self.ex.write(oprot)
9475 
      oprot.writeFieldEnd()
9476 
    oprot.writeFieldStop()
9477 
    oprot.writeStructEnd()
9478 
 
3431 rajveer 9479 
  def validate(self):
9480 
    return
9481 
 
9482 
 
921 rajveer 9483 
  def __repr__(self):
9484 
    L = ['%s=%r' % (key, value)
9485 
      for key, value in self.__dict__.iteritems()]
9486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9487 
 
9488 
  def __eq__(self, other):
9489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9490 
 
9491 
  def __ne__(self, other):
9492 
    return not (self == other)
9493 
 
3064 chandransh 9494 
class getOrder_args:
921 rajveer 9495 
  """
9496 
  Attributes:
3064 chandransh 9497 
   - id
921 rajveer 9498 
  """
9499 
 
9500 
  thrift_spec = (
9501 
    None, # 0
3064 chandransh 9502 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 9503 
  )
9504 
 
3064 chandransh 9505 
  def __init__(self, id=None,):
9506 
    self.id = id
921 rajveer 9507 
 
9508 
  def read(self, iprot):
9509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9511 
      return
9512 
    iprot.readStructBegin()
9513 
    while True:
9514 
      (fname, ftype, fid) = iprot.readFieldBegin()
9515 
      if ftype == TType.STOP:
9516 
        break
9517 
      if fid == 1:
9518 
        if ftype == TType.I64:
3064 chandransh 9519 
          self.id = iprot.readI64();
921 rajveer 9520 
        else:
9521 
          iprot.skip(ftype)
9522 
      else:
9523 
        iprot.skip(ftype)
9524 
      iprot.readFieldEnd()
9525 
    iprot.readStructEnd()
9526 
 
9527 
  def write(self, oprot):
9528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9530 
      return
3064 chandransh 9531 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 9532 
    if self.id is not None:
3064 chandransh 9533 
      oprot.writeFieldBegin('id', TType.I64, 1)
9534 
      oprot.writeI64(self.id)
921 rajveer 9535 
      oprot.writeFieldEnd()
9536 
    oprot.writeFieldStop()
9537 
    oprot.writeStructEnd()
9538 
 
3431 rajveer 9539 
  def validate(self):
9540 
    return
9541 
 
9542 
 
921 rajveer 9543 
  def __repr__(self):
9544 
    L = ['%s=%r' % (key, value)
9545 
      for key, value in self.__dict__.iteritems()]
9546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9547 
 
9548 
  def __eq__(self, other):
9549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9550 
 
9551 
  def __ne__(self, other):
9552 
    return not (self == other)
9553 
 
3064 chandransh 9554 
class getOrder_result:
921 rajveer 9555 
  """
9556 
  Attributes:
9557 
   - success
9558 
   - ex
9559 
  """
9560 
 
9561 
  thrift_spec = (
3064 chandransh 9562 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 9563 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9564 
  )
9565 
 
9566 
  def __init__(self, success=None, ex=None,):
9567 
    self.success = success
9568 
    self.ex = ex
9569 
 
9570 
  def read(self, iprot):
9571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9573 
      return
9574 
    iprot.readStructBegin()
9575 
    while True:
9576 
      (fname, ftype, fid) = iprot.readFieldBegin()
9577 
      if ftype == TType.STOP:
9578 
        break
9579 
      if fid == 0:
3064 chandransh 9580 
        if ftype == TType.STRUCT:
9581 
          self.success = Order()
9582 
          self.success.read(iprot)
921 rajveer 9583 
        else:
9584 
          iprot.skip(ftype)
9585 
      elif fid == 1:
9586 
        if ftype == TType.STRUCT:
9587 
          self.ex = TransactionServiceException()
9588 
          self.ex.read(iprot)
9589 
        else:
9590 
          iprot.skip(ftype)
9591 
      else:
9592 
        iprot.skip(ftype)
9593 
      iprot.readFieldEnd()
9594 
    iprot.readStructEnd()
9595 
 
9596 
  def write(self, oprot):
9597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9599 
      return
3064 chandransh 9600 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 9601 
    if self.success is not None:
3064 chandransh 9602 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9603 
      self.success.write(oprot)
921 rajveer 9604 
      oprot.writeFieldEnd()
3431 rajveer 9605 
    if self.ex is not None:
921 rajveer 9606 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9607 
      self.ex.write(oprot)
9608 
      oprot.writeFieldEnd()
9609 
    oprot.writeFieldStop()
9610 
    oprot.writeStructEnd()
9611 
 
3431 rajveer 9612 
  def validate(self):
9613 
    return
9614 
 
9615 
 
921 rajveer 9616 
  def __repr__(self):
9617 
    L = ['%s=%r' % (key, value)
9618 
      for key, value in self.__dict__.iteritems()]
9619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9620 
 
9621 
  def __eq__(self, other):
9622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9623 
 
9624 
  def __ne__(self, other):
9625 
    return not (self == other)
9626 
 
3064 chandransh 9627 
class getLineItemsForOrder_args:
94 ashish 9628 
  """
9629 
  Attributes:
3064 chandransh 9630 
   - orderId
94 ashish 9631 
  """
9632 
 
9633 
  thrift_spec = (
9634 
    None, # 0
3064 chandransh 9635 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 9636 
  )
9637 
 
3064 chandransh 9638 
  def __init__(self, orderId=None,):
9639 
    self.orderId = orderId
94 ashish 9640 
 
9641 
  def read(self, iprot):
9642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9644 
      return
9645 
    iprot.readStructBegin()
9646 
    while True:
9647 
      (fname, ftype, fid) = iprot.readFieldBegin()
9648 
      if ftype == TType.STOP:
9649 
        break
9650 
      if fid == 1:
9651 
        if ftype == TType.I64:
3064 chandransh 9652 
          self.orderId = iprot.readI64();
94 ashish 9653 
        else:
9654 
          iprot.skip(ftype)
9655 
      else:
9656 
        iprot.skip(ftype)
9657 
      iprot.readFieldEnd()
9658 
    iprot.readStructEnd()
9659 
 
9660 
  def write(self, oprot):
9661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9663 
      return
3064 chandransh 9664 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 9665 
    if self.orderId is not None:
3064 chandransh 9666 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9667 
      oprot.writeI64(self.orderId)
94 ashish 9668 
      oprot.writeFieldEnd()
9669 
    oprot.writeFieldStop()
9670 
    oprot.writeStructEnd()
9671 
 
3431 rajveer 9672 
  def validate(self):
9673 
    return
9674 
 
9675 
 
94 ashish 9676 
  def __repr__(self):
9677 
    L = ['%s=%r' % (key, value)
9678 
      for key, value in self.__dict__.iteritems()]
9679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9680 
 
9681 
  def __eq__(self, other):
9682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9683 
 
9684 
  def __ne__(self, other):
9685 
    return not (self == other)
9686 
 
3064 chandransh 9687 
class getLineItemsForOrder_result:
94 ashish 9688 
  """
9689 
  Attributes:
9690 
   - success
9691 
   - ex
9692 
  """
9693 
 
9694 
  thrift_spec = (
3064 chandransh 9695 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 9696 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9697 
  )
9698 
 
9699 
  def __init__(self, success=None, ex=None,):
9700 
    self.success = success
9701 
    self.ex = ex
9702 
 
9703 
  def read(self, iprot):
9704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9706 
      return
9707 
    iprot.readStructBegin()
9708 
    while True:
9709 
      (fname, ftype, fid) = iprot.readFieldBegin()
9710 
      if ftype == TType.STOP:
9711 
        break
9712 
      if fid == 0:
483 rajveer 9713 
        if ftype == TType.LIST:
9714 
          self.success = []
5031 varun.gupt 9715 
          (_etype164, _size161) = iprot.readListBegin()
9716 
          for _i165 in xrange(_size161):
9717 
            _elem166 = LineItem()
9718 
            _elem166.read(iprot)
9719 
            self.success.append(_elem166)
483 rajveer 9720 
          iprot.readListEnd()
94 ashish 9721 
        else:
9722 
          iprot.skip(ftype)
9723 
      elif fid == 1:
9724 
        if ftype == TType.STRUCT:
9725 
          self.ex = TransactionServiceException()
9726 
          self.ex.read(iprot)
9727 
        else:
9728 
          iprot.skip(ftype)
9729 
      else:
9730 
        iprot.skip(ftype)
9731 
      iprot.readFieldEnd()
9732 
    iprot.readStructEnd()
9733 
 
9734 
  def write(self, oprot):
9735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9737 
      return
3064 chandransh 9738 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 9739 
    if self.success is not None:
483 rajveer 9740 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9741 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9742 
      for iter167 in self.success:
9743 
        iter167.write(oprot)
483 rajveer 9744 
      oprot.writeListEnd()
94 ashish 9745 
      oprot.writeFieldEnd()
3431 rajveer 9746 
    if self.ex is not None:
94 ashish 9747 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9748 
      self.ex.write(oprot)
9749 
      oprot.writeFieldEnd()
9750 
    oprot.writeFieldStop()
9751 
    oprot.writeStructEnd()
9752 
 
3431 rajveer 9753 
  def validate(self):
9754 
    return
9755 
 
9756 
 
94 ashish 9757 
  def __repr__(self):
9758 
    L = ['%s=%r' % (key, value)
9759 
      for key, value in self.__dict__.iteritems()]
9760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9761 
 
9762 
  def __eq__(self, other):
9763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9764 
 
9765 
  def __ne__(self, other):
9766 
    return not (self == other)
9767 
 
4999 phani.kuma 9768 
class getOrderList_args:
9769 
  """
9770 
  Attributes:
9771 
   - order_ids
9772 
  """
9773 
 
9774 
  thrift_spec = (
9775 
    None, # 0
9776 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
9777 
  )
9778 
 
9779 
  def __init__(self, order_ids=None,):
9780 
    self.order_ids = order_ids
9781 
 
9782 
  def read(self, iprot):
9783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9785 
      return
9786 
    iprot.readStructBegin()
9787 
    while True:
9788 
      (fname, ftype, fid) = iprot.readFieldBegin()
9789 
      if ftype == TType.STOP:
9790 
        break
9791 
      if fid == 1:
9792 
        if ftype == TType.LIST:
9793 
          self.order_ids = []
5031 varun.gupt 9794 
          (_etype171, _size168) = iprot.readListBegin()
9795 
          for _i172 in xrange(_size168):
9796 
            _elem173 = iprot.readI64();
9797 
            self.order_ids.append(_elem173)
4999 phani.kuma 9798 
          iprot.readListEnd()
9799 
        else:
9800 
          iprot.skip(ftype)
9801 
      else:
9802 
        iprot.skip(ftype)
9803 
      iprot.readFieldEnd()
9804 
    iprot.readStructEnd()
9805 
 
9806 
  def write(self, oprot):
9807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9809 
      return
9810 
    oprot.writeStructBegin('getOrderList_args')
9811 
    if self.order_ids is not None:
9812 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
9813 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
5031 varun.gupt 9814 
      for iter174 in self.order_ids:
9815 
        oprot.writeI64(iter174)
4999 phani.kuma 9816 
      oprot.writeListEnd()
9817 
      oprot.writeFieldEnd()
9818 
    oprot.writeFieldStop()
9819 
    oprot.writeStructEnd()
9820 
 
9821 
  def validate(self):
9822 
    return
9823 
 
9824 
 
9825 
  def __repr__(self):
9826 
    L = ['%s=%r' % (key, value)
9827 
      for key, value in self.__dict__.iteritems()]
9828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9829 
 
9830 
  def __eq__(self, other):
9831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9832 
 
9833 
  def __ne__(self, other):
9834 
    return not (self == other)
9835 
 
9836 
class getOrderList_result:
9837 
  """
9838 
  Attributes:
9839 
   - success
9840 
  """
9841 
 
9842 
  thrift_spec = (
9843 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9844 
  )
9845 
 
9846 
  def __init__(self, success=None,):
9847 
    self.success = success
9848 
 
9849 
  def read(self, iprot):
9850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9852 
      return
9853 
    iprot.readStructBegin()
9854 
    while True:
9855 
      (fname, ftype, fid) = iprot.readFieldBegin()
9856 
      if ftype == TType.STOP:
9857 
        break
9858 
      if fid == 0:
9859 
        if ftype == TType.LIST:
9860 
          self.success = []
5031 varun.gupt 9861 
          (_etype178, _size175) = iprot.readListBegin()
9862 
          for _i179 in xrange(_size175):
9863 
            _elem180 = Order()
9864 
            _elem180.read(iprot)
9865 
            self.success.append(_elem180)
4999 phani.kuma 9866 
          iprot.readListEnd()
9867 
        else:
9868 
          iprot.skip(ftype)
9869 
      else:
9870 
        iprot.skip(ftype)
9871 
      iprot.readFieldEnd()
9872 
    iprot.readStructEnd()
9873 
 
9874 
  def write(self, oprot):
9875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9877 
      return
9878 
    oprot.writeStructBegin('getOrderList_result')
9879 
    if self.success is not None:
9880 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9881 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9882 
      for iter181 in self.success:
9883 
        iter181.write(oprot)
4999 phani.kuma 9884 
      oprot.writeListEnd()
9885 
      oprot.writeFieldEnd()
9886 
    oprot.writeFieldStop()
9887 
    oprot.writeStructEnd()
9888 
 
9889 
  def validate(self):
9890 
    return
9891 
 
9892 
 
9893 
  def __repr__(self):
9894 
    L = ['%s=%r' % (key, value)
9895 
      for key, value in self.__dict__.iteritems()]
9896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9897 
 
9898 
  def __eq__(self, other):
9899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9900 
 
9901 
  def __ne__(self, other):
9902 
    return not (self == other)
9903 
 
3064 chandransh 9904 
class getOrderForCustomer_args:
94 ashish 9905 
  """
9906 
  Attributes:
3064 chandransh 9907 
   - orderId
483 rajveer 9908 
   - customerId
94 ashish 9909 
  """
9910 
 
9911 
  thrift_spec = (
9912 
    None, # 0
3064 chandransh 9913 
    (1, TType.I64, 'orderId', None, None, ), # 1
9914 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 9915 
  )
9916 
 
3064 chandransh 9917 
  def __init__(self, orderId=None, customerId=None,):
9918 
    self.orderId = orderId
483 rajveer 9919 
    self.customerId = customerId
94 ashish 9920 
 
9921 
  def read(self, iprot):
9922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9924 
      return
9925 
    iprot.readStructBegin()
9926 
    while True:
9927 
      (fname, ftype, fid) = iprot.readFieldBegin()
9928 
      if ftype == TType.STOP:
9929 
        break
9930 
      if fid == 1:
9931 
        if ftype == TType.I64:
3064 chandransh 9932 
          self.orderId = iprot.readI64();
94 ashish 9933 
        else:
9934 
          iprot.skip(ftype)
9935 
      elif fid == 2:
9936 
        if ftype == TType.I64:
3064 chandransh 9937 
          self.customerId = iprot.readI64();
94 ashish 9938 
        else:
9939 
          iprot.skip(ftype)
9940 
      else:
9941 
        iprot.skip(ftype)
9942 
      iprot.readFieldEnd()
9943 
    iprot.readStructEnd()
9944 
 
9945 
  def write(self, oprot):
9946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9948 
      return
3064 chandransh 9949 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 9950 
    if self.orderId is not None:
3064 chandransh 9951 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9952 
      oprot.writeI64(self.orderId)
9953 
      oprot.writeFieldEnd()
3431 rajveer 9954 
    if self.customerId is not None:
3064 chandransh 9955 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 9956 
      oprot.writeI64(self.customerId)
94 ashish 9957 
      oprot.writeFieldEnd()
9958 
    oprot.writeFieldStop()
9959 
    oprot.writeStructEnd()
9960 
 
3431 rajveer 9961 
  def validate(self):
9962 
    return
9963 
 
9964 
 
94 ashish 9965 
  def __repr__(self):
9966 
    L = ['%s=%r' % (key, value)
9967 
      for key, value in self.__dict__.iteritems()]
9968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9969 
 
9970 
  def __eq__(self, other):
9971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9972 
 
9973 
  def __ne__(self, other):
9974 
    return not (self == other)
9975 
 
3064 chandransh 9976 
class getOrderForCustomer_result:
94 ashish 9977 
  """
9978 
  Attributes:
9979 
   - success
9980 
   - ex
9981 
  """
9982 
 
9983 
  thrift_spec = (
3064 chandransh 9984 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 9985 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9986 
  )
9987 
 
9988 
  def __init__(self, success=None, ex=None,):
9989 
    self.success = success
9990 
    self.ex = ex
9991 
 
9992 
  def read(self, iprot):
9993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9995 
      return
9996 
    iprot.readStructBegin()
9997 
    while True:
9998 
      (fname, ftype, fid) = iprot.readFieldBegin()
9999 
      if ftype == TType.STOP:
10000 
        break
10001 
      if fid == 0:
3064 chandransh 10002 
        if ftype == TType.STRUCT:
10003 
          self.success = Order()
10004 
          self.success.read(iprot)
94 ashish 10005 
        else:
10006 
          iprot.skip(ftype)
10007 
      elif fid == 1:
10008 
        if ftype == TType.STRUCT:
10009 
          self.ex = TransactionServiceException()
10010 
          self.ex.read(iprot)
10011 
        else:
10012 
          iprot.skip(ftype)
10013 
      else:
10014 
        iprot.skip(ftype)
10015 
      iprot.readFieldEnd()
10016 
    iprot.readStructEnd()
10017 
 
10018 
  def write(self, oprot):
10019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10021 
      return
3064 chandransh 10022 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 10023 
    if self.success is not None:
3064 chandransh 10024 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10025 
      self.success.write(oprot)
94 ashish 10026 
      oprot.writeFieldEnd()
3431 rajveer 10027 
    if self.ex is not None:
94 ashish 10028 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10029 
      self.ex.write(oprot)
10030 
      oprot.writeFieldEnd()
10031 
    oprot.writeFieldStop()
10032 
    oprot.writeStructEnd()
10033 
 
3431 rajveer 10034 
  def validate(self):
10035 
    return
10036 
 
10037 
 
94 ashish 10038 
  def __repr__(self):
10039 
    L = ['%s=%r' % (key, value)
10040 
      for key, value in self.__dict__.iteritems()]
10041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10042 
 
10043 
  def __eq__(self, other):
10044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10045 
 
10046 
  def __ne__(self, other):
10047 
    return not (self == other)
10048 
 
3064 chandransh 10049 
class getAlerts_args:
94 ashish 10050 
  """
10051 
  Attributes:
4394 rajveer 10052 
   - type
4444 rajveer 10053 
   - warehouseId
4394 rajveer 10054 
   - status
10055 
   - timestamp
94 ashish 10056 
  """
10057 
 
10058 
  thrift_spec = (
10059 
    None, # 0
4394 rajveer 10060 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10061 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10062 
    (3, TType.I64, 'status', None, None, ), # 3
10063 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 10064 
  )
10065 
 
4444 rajveer 10066 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 10067 
    self.type = type
4444 rajveer 10068 
    self.warehouseId = warehouseId
4394 rajveer 10069 
    self.status = status
10070 
    self.timestamp = timestamp
94 ashish 10071 
 
10072 
  def read(self, iprot):
10073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10075 
      return
10076 
    iprot.readStructBegin()
10077 
    while True:
10078 
      (fname, ftype, fid) = iprot.readFieldBegin()
10079 
      if ftype == TType.STOP:
10080 
        break
10081 
      if fid == 1:
3064 chandransh 10082 
        if ftype == TType.I64:
4394 rajveer 10083 
          self.type = iprot.readI64();
94 ashish 10084 
        else:
10085 
          iprot.skip(ftype)
3064 chandransh 10086 
      elif fid == 2:
4394 rajveer 10087 
        if ftype == TType.I64:
4444 rajveer 10088 
          self.warehouseId = iprot.readI64();
3064 chandransh 10089 
        else:
10090 
          iprot.skip(ftype)
4394 rajveer 10091 
      elif fid == 3:
10092 
        if ftype == TType.I64:
4444 rajveer 10093 
          self.status = iprot.readI64();
10094 
        else:
10095 
          iprot.skip(ftype)
10096 
      elif fid == 4:
10097 
        if ftype == TType.I64:
4394 rajveer 10098 
          self.timestamp = iprot.readI64();
10099 
        else:
10100 
          iprot.skip(ftype)
94 ashish 10101 
      else:
10102 
        iprot.skip(ftype)
10103 
      iprot.readFieldEnd()
10104 
    iprot.readStructEnd()
10105 
 
10106 
  def write(self, oprot):
10107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10109 
      return
3064 chandransh 10110 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 10111 
    if self.type is not None:
10112 
      oprot.writeFieldBegin('type', TType.I64, 1)
10113 
      oprot.writeI64(self.type)
94 ashish 10114 
      oprot.writeFieldEnd()
4444 rajveer 10115 
    if self.warehouseId is not None:
10116 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10117 
      oprot.writeI64(self.warehouseId)
10118 
      oprot.writeFieldEnd()
4394 rajveer 10119 
    if self.status is not None:
4444 rajveer 10120 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 10121 
      oprot.writeI64(self.status)
3064 chandransh 10122 
      oprot.writeFieldEnd()
4394 rajveer 10123 
    if self.timestamp is not None:
4444 rajveer 10124 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 10125 
      oprot.writeI64(self.timestamp)
10126 
      oprot.writeFieldEnd()
94 ashish 10127 
    oprot.writeFieldStop()
10128 
    oprot.writeStructEnd()
10129 
 
3431 rajveer 10130 
  def validate(self):
10131 
    return
10132 
 
10133 
 
94 ashish 10134 
  def __repr__(self):
10135 
    L = ['%s=%r' % (key, value)
10136 
      for key, value in self.__dict__.iteritems()]
10137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10138 
 
10139 
  def __eq__(self, other):
10140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10141 
 
10142 
  def __ne__(self, other):
10143 
    return not (self == other)
10144 
 
3064 chandransh 10145 
class getAlerts_result:
94 ashish 10146 
  """
10147 
  Attributes:
10148 
   - success
10149 
  """
10150 
 
10151 
  thrift_spec = (
3064 chandransh 10152 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 10153 
  )
10154 
 
3064 chandransh 10155 
  def __init__(self, success=None,):
94 ashish 10156 
    self.success = success
10157 
 
10158 
  def read(self, iprot):
10159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10161 
      return
10162 
    iprot.readStructBegin()
10163 
    while True:
10164 
      (fname, ftype, fid) = iprot.readFieldBegin()
10165 
      if ftype == TType.STOP:
10166 
        break
10167 
      if fid == 0:
3064 chandransh 10168 
        if ftype == TType.LIST:
10169 
          self.success = []
5031 varun.gupt 10170 
          (_etype185, _size182) = iprot.readListBegin()
10171 
          for _i186 in xrange(_size182):
10172 
            _elem187 = Alert()
10173 
            _elem187.read(iprot)
10174 
            self.success.append(_elem187)
3064 chandransh 10175 
          iprot.readListEnd()
94 ashish 10176 
        else:
10177 
          iprot.skip(ftype)
10178 
      else:
10179 
        iprot.skip(ftype)
10180 
      iprot.readFieldEnd()
10181 
    iprot.readStructEnd()
10182 
 
10183 
  def write(self, oprot):
10184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10186 
      return
3064 chandransh 10187 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 10188 
    if self.success is not None:
3064 chandransh 10189 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10190 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10191 
      for iter188 in self.success:
10192 
        iter188.write(oprot)
3064 chandransh 10193 
      oprot.writeListEnd()
94 ashish 10194 
      oprot.writeFieldEnd()
10195 
    oprot.writeFieldStop()
10196 
    oprot.writeStructEnd()
10197 
 
3431 rajveer 10198 
  def validate(self):
10199 
    return
10200 
 
10201 
 
94 ashish 10202 
  def __repr__(self):
10203 
    L = ['%s=%r' % (key, value)
10204 
      for key, value in self.__dict__.iteritems()]
10205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10206 
 
10207 
  def __eq__(self, other):
10208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10209 
 
10210 
  def __ne__(self, other):
10211 
    return not (self == other)
10212 
 
4394 rajveer 10213 
class addAlert_args:
94 ashish 10214 
  """
10215 
  Attributes:
3064 chandransh 10216 
   - type
4444 rajveer 10217 
   - warehouseId
4394 rajveer 10218 
   - description
94 ashish 10219 
  """
10220 
 
10221 
  thrift_spec = (
10222 
    None, # 0
4394 rajveer 10223 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10224 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10225 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10226 
  )
10227 
 
4444 rajveer 10228 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 10229 
    self.type = type
4444 rajveer 10230 
    self.warehouseId = warehouseId
4394 rajveer 10231 
    self.description = description
94 ashish 10232 
 
10233 
  def read(self, iprot):
10234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10236 
      return
10237 
    iprot.readStructBegin()
10238 
    while True:
10239 
      (fname, ftype, fid) = iprot.readFieldBegin()
10240 
      if ftype == TType.STOP:
10241 
        break
10242 
      if fid == 1:
10243 
        if ftype == TType.I64:
4394 rajveer 10244 
          self.type = iprot.readI64();
94 ashish 10245 
        else:
10246 
          iprot.skip(ftype)
3064 chandransh 10247 
      elif fid == 2:
4444 rajveer 10248 
        if ftype == TType.I64:
10249 
          self.warehouseId = iprot.readI64();
10250 
        else:
10251 
          iprot.skip(ftype)
10252 
      elif fid == 3:
3064 chandransh 10253 
        if ftype == TType.STRING:
4394 rajveer 10254 
          self.description = iprot.readString();
3064 chandransh 10255 
        else:
10256 
          iprot.skip(ftype)
94 ashish 10257 
      else:
10258 
        iprot.skip(ftype)
10259 
      iprot.readFieldEnd()
10260 
    iprot.readStructEnd()
10261 
 
10262 
  def write(self, oprot):
10263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10265 
      return
4394 rajveer 10266 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 10267 
    if self.type is not None:
4394 rajveer 10268 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 10269 
      oprot.writeI64(self.type)
10270 
      oprot.writeFieldEnd()
4444 rajveer 10271 
    if self.warehouseId is not None:
10272 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10273 
      oprot.writeI64(self.warehouseId)
10274 
      oprot.writeFieldEnd()
4394 rajveer 10275 
    if self.description is not None:
4444 rajveer 10276 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 10277 
      oprot.writeString(self.description)
3064 chandransh 10278 
      oprot.writeFieldEnd()
94 ashish 10279 
    oprot.writeFieldStop()
10280 
    oprot.writeStructEnd()
10281 
 
3431 rajveer 10282 
  def validate(self):
10283 
    return
10284 
 
10285 
 
94 ashish 10286 
  def __repr__(self):
10287 
    L = ['%s=%r' % (key, value)
10288 
      for key, value in self.__dict__.iteritems()]
10289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10290 
 
10291 
  def __eq__(self, other):
10292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10293 
 
10294 
  def __ne__(self, other):
10295 
    return not (self == other)
10296 
 
4394 rajveer 10297 
class addAlert_result:
3064 chandransh 10298 
 
10299 
  thrift_spec = (
10300 
  )
10301 
 
10302 
  def read(self, iprot):
10303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10305 
      return
10306 
    iprot.readStructBegin()
10307 
    while True:
10308 
      (fname, ftype, fid) = iprot.readFieldBegin()
10309 
      if ftype == TType.STOP:
10310 
        break
10311 
      else:
10312 
        iprot.skip(ftype)
10313 
      iprot.readFieldEnd()
10314 
    iprot.readStructEnd()
10315 
 
10316 
  def write(self, oprot):
10317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10319 
      return
4394 rajveer 10320 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 10321 
    oprot.writeFieldStop()
10322 
    oprot.writeStructEnd()
10323 
 
3431 rajveer 10324 
  def validate(self):
10325 
    return
10326 
 
10327 
 
3064 chandransh 10328 
  def __repr__(self):
10329 
    L = ['%s=%r' % (key, value)
10330 
      for key, value in self.__dict__.iteritems()]
10331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10332 
 
10333 
  def __eq__(self, other):
10334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10335 
 
10336 
  def __ne__(self, other):
10337 
    return not (self == other)
10338 
 
4444 rajveer 10339 
class markAlertsAsSeen_args:
10340 
  """
10341 
  Attributes:
10342 
   - warehouseId
10343 
  """
10344 
 
10345 
  thrift_spec = (
10346 
    None, # 0
10347 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10348 
  )
10349 
 
10350 
  def __init__(self, warehouseId=None,):
10351 
    self.warehouseId = warehouseId
10352 
 
10353 
  def read(self, iprot):
10354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10356 
      return
10357 
    iprot.readStructBegin()
10358 
    while True:
10359 
      (fname, ftype, fid) = iprot.readFieldBegin()
10360 
      if ftype == TType.STOP:
10361 
        break
10362 
      if fid == 1:
10363 
        if ftype == TType.I64:
10364 
          self.warehouseId = iprot.readI64();
10365 
        else:
10366 
          iprot.skip(ftype)
10367 
      else:
10368 
        iprot.skip(ftype)
10369 
      iprot.readFieldEnd()
10370 
    iprot.readStructEnd()
10371 
 
10372 
  def write(self, oprot):
10373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10375 
      return
10376 
    oprot.writeStructBegin('markAlertsAsSeen_args')
10377 
    if self.warehouseId is not None:
10378 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10379 
      oprot.writeI64(self.warehouseId)
10380 
      oprot.writeFieldEnd()
10381 
    oprot.writeFieldStop()
10382 
    oprot.writeStructEnd()
10383 
 
10384 
  def validate(self):
10385 
    return
10386 
 
10387 
 
10388 
  def __repr__(self):
10389 
    L = ['%s=%r' % (key, value)
10390 
      for key, value in self.__dict__.iteritems()]
10391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10392 
 
10393 
  def __eq__(self, other):
10394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10395 
 
10396 
  def __ne__(self, other):
10397 
    return not (self == other)
10398 
 
10399 
class markAlertsAsSeen_result:
10400 
 
10401 
  thrift_spec = (
10402 
  )
10403 
 
10404 
  def read(self, iprot):
10405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10407 
      return
10408 
    iprot.readStructBegin()
10409 
    while True:
10410 
      (fname, ftype, fid) = iprot.readFieldBegin()
10411 
      if ftype == TType.STOP:
10412 
        break
10413 
      else:
10414 
        iprot.skip(ftype)
10415 
      iprot.readFieldEnd()
10416 
    iprot.readStructEnd()
10417 
 
10418 
  def write(self, oprot):
10419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10421 
      return
10422 
    oprot.writeStructBegin('markAlertsAsSeen_result')
10423 
    oprot.writeFieldStop()
10424 
    oprot.writeStructEnd()
10425 
 
10426 
  def validate(self):
10427 
    return
10428 
 
10429 
 
10430 
  def __repr__(self):
10431 
    L = ['%s=%r' % (key, value)
10432 
      for key, value in self.__dict__.iteritems()]
10433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10434 
 
10435 
  def __eq__(self, other):
10436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10437 
 
10438 
  def __ne__(self, other):
10439 
    return not (self == other)
10440 
 
3064 chandransh 10441 
class getValidOrderCount_args:
10442 
 
10443 
  thrift_spec = (
10444 
  )
10445 
 
10446 
  def read(self, iprot):
10447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10449 
      return
10450 
    iprot.readStructBegin()
10451 
    while True:
10452 
      (fname, ftype, fid) = iprot.readFieldBegin()
10453 
      if ftype == TType.STOP:
10454 
        break
10455 
      else:
10456 
        iprot.skip(ftype)
10457 
      iprot.readFieldEnd()
10458 
    iprot.readStructEnd()
10459 
 
10460 
  def write(self, oprot):
10461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10463 
      return
10464 
    oprot.writeStructBegin('getValidOrderCount_args')
10465 
    oprot.writeFieldStop()
10466 
    oprot.writeStructEnd()
10467 
 
3431 rajveer 10468 
  def validate(self):
10469 
    return
10470 
 
10471 
 
3064 chandransh 10472 
  def __repr__(self):
10473 
    L = ['%s=%r' % (key, value)
10474 
      for key, value in self.__dict__.iteritems()]
10475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10476 
 
10477 
  def __eq__(self, other):
10478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10479 
 
10480 
  def __ne__(self, other):
10481 
    return not (self == other)
10482 
 
10483 
class getValidOrderCount_result:
94 ashish 10484 
  """
10485 
  Attributes:
10486 
   - success
10487 
  """
10488 
 
10489 
  thrift_spec = (
3064 chandransh 10490 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10491 
  )
10492 
 
3064 chandransh 10493 
  def __init__(self, success=None,):
94 ashish 10494 
    self.success = success
10495 
 
10496 
  def read(self, iprot):
10497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10499 
      return
10500 
    iprot.readStructBegin()
10501 
    while True:
10502 
      (fname, ftype, fid) = iprot.readFieldBegin()
10503 
      if ftype == TType.STOP:
10504 
        break
10505 
      if fid == 0:
3064 chandransh 10506 
        if ftype == TType.I64:
10507 
          self.success = iprot.readI64();
94 ashish 10508 
        else:
10509 
          iprot.skip(ftype)
10510 
      else:
10511 
        iprot.skip(ftype)
10512 
      iprot.readFieldEnd()
10513 
    iprot.readStructEnd()
10514 
 
10515 
  def write(self, oprot):
10516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10518 
      return
3064 chandransh 10519 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 10520 
    if self.success is not None:
3064 chandransh 10521 
      oprot.writeFieldBegin('success', TType.I64, 0)
10522 
      oprot.writeI64(self.success)
94 ashish 10523 
      oprot.writeFieldEnd()
10524 
    oprot.writeFieldStop()
10525 
    oprot.writeStructEnd()
10526 
 
3431 rajveer 10527 
  def validate(self):
10528 
    return
10529 
 
10530 
 
94 ashish 10531 
  def __repr__(self):
10532 
    L = ['%s=%r' % (key, value)
10533 
      for key, value in self.__dict__.iteritems()]
10534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10535 
 
10536 
  def __eq__(self, other):
10537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10538 
 
10539 
  def __ne__(self, other):
10540 
    return not (self == other)
10541 
 
3064 chandransh 10542 
class getNoOfCustomersWithSuccessfulTransaction_args:
10543 
 
10544 
  thrift_spec = (
10545 
  )
10546 
 
10547 
  def read(self, iprot):
10548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10550 
      return
10551 
    iprot.readStructBegin()
10552 
    while True:
10553 
      (fname, ftype, fid) = iprot.readFieldBegin()
10554 
      if ftype == TType.STOP:
10555 
        break
10556 
      else:
10557 
        iprot.skip(ftype)
10558 
      iprot.readFieldEnd()
10559 
    iprot.readStructEnd()
10560 
 
10561 
  def write(self, oprot):
10562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10564 
      return
10565 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
10566 
    oprot.writeFieldStop()
10567 
    oprot.writeStructEnd()
10568 
 
3431 rajveer 10569 
  def validate(self):
10570 
    return
10571 
 
10572 
 
3064 chandransh 10573 
  def __repr__(self):
10574 
    L = ['%s=%r' % (key, value)
10575 
      for key, value in self.__dict__.iteritems()]
10576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10577 
 
10578 
  def __eq__(self, other):
10579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10580 
 
10581 
  def __ne__(self, other):
10582 
    return not (self == other)
10583 
 
10584 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 10585 
  """
10586 
  Attributes:
3064 chandransh 10587 
   - success
94 ashish 10588 
  """
10589 
 
10590 
  thrift_spec = (
3064 chandransh 10591 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10592 
  )
10593 
 
3064 chandransh 10594 
  def __init__(self, success=None,):
10595 
    self.success = success
94 ashish 10596 
 
10597 
  def read(self, iprot):
10598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10600 
      return
10601 
    iprot.readStructBegin()
10602 
    while True:
10603 
      (fname, ftype, fid) = iprot.readFieldBegin()
10604 
      if ftype == TType.STOP:
10605 
        break
3064 chandransh 10606 
      if fid == 0:
94 ashish 10607 
        if ftype == TType.I64:
3064 chandransh 10608 
          self.success = iprot.readI64();
94 ashish 10609 
        else:
10610 
          iprot.skip(ftype)
10611 
      else:
10612 
        iprot.skip(ftype)
10613 
      iprot.readFieldEnd()
10614 
    iprot.readStructEnd()
10615 
 
10616 
  def write(self, oprot):
10617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10619 
      return
3064 chandransh 10620 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 10621 
    if self.success is not None:
3064 chandransh 10622 
      oprot.writeFieldBegin('success', TType.I64, 0)
10623 
      oprot.writeI64(self.success)
94 ashish 10624 
      oprot.writeFieldEnd()
10625 
    oprot.writeFieldStop()
10626 
    oprot.writeStructEnd()
10627 
 
3431 rajveer 10628 
  def validate(self):
10629 
    return
10630 
 
10631 
 
94 ashish 10632 
  def __repr__(self):
10633 
    L = ['%s=%r' % (key, value)
10634 
      for key, value in self.__dict__.iteritems()]
10635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10636 
 
10637 
  def __eq__(self, other):
10638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10639 
 
10640 
  def __ne__(self, other):
10641 
    return not (self == other)
10642 
 
3064 chandransh 10643 
class getValidOrdersAmountRange_args:
10644 
 
10645 
  thrift_spec = (
10646 
  )
10647 
 
10648 
  def read(self, iprot):
10649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10651 
      return
10652 
    iprot.readStructBegin()
10653 
    while True:
10654 
      (fname, ftype, fid) = iprot.readFieldBegin()
10655 
      if ftype == TType.STOP:
10656 
        break
10657 
      else:
10658 
        iprot.skip(ftype)
10659 
      iprot.readFieldEnd()
10660 
    iprot.readStructEnd()
10661 
 
10662 
  def write(self, oprot):
10663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10665 
      return
10666 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
10667 
    oprot.writeFieldStop()
10668 
    oprot.writeStructEnd()
10669 
 
3431 rajveer 10670 
  def validate(self):
10671 
    return
10672 
 
10673 
 
3064 chandransh 10674 
  def __repr__(self):
10675 
    L = ['%s=%r' % (key, value)
10676 
      for key, value in self.__dict__.iteritems()]
10677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10678 
 
10679 
  def __eq__(self, other):
10680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10681 
 
10682 
  def __ne__(self, other):
10683 
    return not (self == other)
10684 
 
10685 
class getValidOrdersAmountRange_result:
94 ashish 10686 
  """
10687 
  Attributes:
10688 
   - success
10689 
  """
10690 
 
10691 
  thrift_spec = (
3064 chandransh 10692 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 10693 
  )
10694 
 
3064 chandransh 10695 
  def __init__(self, success=None,):
94 ashish 10696 
    self.success = success
10697 
 
10698 
  def read(self, iprot):
10699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10701 
      return
10702 
    iprot.readStructBegin()
10703 
    while True:
10704 
      (fname, ftype, fid) = iprot.readFieldBegin()
10705 
      if ftype == TType.STOP:
10706 
        break
10707 
      if fid == 0:
483 rajveer 10708 
        if ftype == TType.LIST:
10709 
          self.success = []
5031 varun.gupt 10710 
          (_etype192, _size189) = iprot.readListBegin()
10711 
          for _i193 in xrange(_size189):
10712 
            _elem194 = iprot.readDouble();
10713 
            self.success.append(_elem194)
483 rajveer 10714 
          iprot.readListEnd()
94 ashish 10715 
        else:
10716 
          iprot.skip(ftype)
10717 
      else:
10718 
        iprot.skip(ftype)
10719 
      iprot.readFieldEnd()
10720 
    iprot.readStructEnd()
10721 
 
10722 
  def write(self, oprot):
10723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10725 
      return
3064 chandransh 10726 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 10727 
    if self.success is not None:
483 rajveer 10728 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 10729 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
5031 varun.gupt 10730 
      for iter195 in self.success:
10731 
        oprot.writeDouble(iter195)
483 rajveer 10732 
      oprot.writeListEnd()
94 ashish 10733 
      oprot.writeFieldEnd()
10734 
    oprot.writeFieldStop()
10735 
    oprot.writeStructEnd()
10736 
 
3431 rajveer 10737 
  def validate(self):
10738 
    return
10739 
 
10740 
 
94 ashish 10741 
  def __repr__(self):
10742 
    L = ['%s=%r' % (key, value)
10743 
      for key, value in self.__dict__.iteritems()]
10744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10745 
 
10746 
  def __eq__(self, other):
10747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10748 
 
10749 
  def __ne__(self, other):
10750 
    return not (self == other)
10751 
 
3064 chandransh 10752 
class getValidOrders_args:
1528 ankur.sing 10753 
  """
10754 
  Attributes:
3064 chandransh 10755 
   - limit
1528 ankur.sing 10756 
  """
10757 
 
10758 
  thrift_spec = (
10759 
    None, # 0
3064 chandransh 10760 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 10761 
  )
10762 
 
3064 chandransh 10763 
  def __init__(self, limit=None,):
10764 
    self.limit = limit
1528 ankur.sing 10765 
 
10766 
  def read(self, iprot):
10767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10769 
      return
10770 
    iprot.readStructBegin()
10771 
    while True:
10772 
      (fname, ftype, fid) = iprot.readFieldBegin()
10773 
      if ftype == TType.STOP:
10774 
        break
10775 
      if fid == 1:
10776 
        if ftype == TType.I64:
3064 chandransh 10777 
          self.limit = iprot.readI64();
1528 ankur.sing 10778 
        else:
10779 
          iprot.skip(ftype)
10780 
      else:
10781 
        iprot.skip(ftype)
10782 
      iprot.readFieldEnd()
10783 
    iprot.readStructEnd()
10784 
 
10785 
  def write(self, oprot):
10786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10788 
      return
3064 chandransh 10789 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 10790 
    if self.limit is not None:
3064 chandransh 10791 
      oprot.writeFieldBegin('limit', TType.I64, 1)
10792 
      oprot.writeI64(self.limit)
1528 ankur.sing 10793 
      oprot.writeFieldEnd()
10794 
    oprot.writeFieldStop()
10795 
    oprot.writeStructEnd()
10796 
 
3431 rajveer 10797 
  def validate(self):
10798 
    return
10799 
 
10800 
 
1528 ankur.sing 10801 
  def __repr__(self):
10802 
    L = ['%s=%r' % (key, value)
10803 
      for key, value in self.__dict__.iteritems()]
10804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10805 
 
10806 
  def __eq__(self, other):
10807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10808 
 
10809 
  def __ne__(self, other):
10810 
    return not (self == other)
10811 
 
3064 chandransh 10812 
class getValidOrders_result:
1528 ankur.sing 10813 
  """
10814 
  Attributes:
10815 
   - success
10816 
  """
10817 
 
10818 
  thrift_spec = (
3064 chandransh 10819 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 10820 
  )
10821 
 
3064 chandransh 10822 
  def __init__(self, success=None,):
1528 ankur.sing 10823 
    self.success = success
10824 
 
10825 
  def read(self, iprot):
10826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10828 
      return
10829 
    iprot.readStructBegin()
10830 
    while True:
10831 
      (fname, ftype, fid) = iprot.readFieldBegin()
10832 
      if ftype == TType.STOP:
10833 
        break
10834 
      if fid == 0:
3064 chandransh 10835 
        if ftype == TType.LIST:
10836 
          self.success = []
5031 varun.gupt 10837 
          (_etype199, _size196) = iprot.readListBegin()
10838 
          for _i200 in xrange(_size196):
10839 
            _elem201 = Order()
10840 
            _elem201.read(iprot)
10841 
            self.success.append(_elem201)
3064 chandransh 10842 
          iprot.readListEnd()
1528 ankur.sing 10843 
        else:
10844 
          iprot.skip(ftype)
10845 
      else:
10846 
        iprot.skip(ftype)
10847 
      iprot.readFieldEnd()
10848 
    iprot.readStructEnd()
10849 
 
10850 
  def write(self, oprot):
10851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10853 
      return
3064 chandransh 10854 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 10855 
    if self.success is not None:
3064 chandransh 10856 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10857 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10858 
      for iter202 in self.success:
10859 
        iter202.write(oprot)
3064 chandransh 10860 
      oprot.writeListEnd()
1528 ankur.sing 10861 
      oprot.writeFieldEnd()
10862 
    oprot.writeFieldStop()
10863 
    oprot.writeStructEnd()
10864 
 
3431 rajveer 10865 
  def validate(self):
10866 
    return
10867 
 
10868 
 
1528 ankur.sing 10869 
  def __repr__(self):
10870 
    L = ['%s=%r' % (key, value)
10871 
      for key, value in self.__dict__.iteritems()]
10872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10873 
 
10874 
  def __eq__(self, other):
10875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10876 
 
10877 
  def __ne__(self, other):
10878 
    return not (self == other)
10879 
 
1220 chandransh 10880 
class batchOrders_args:
10881 
  """
10882 
  Attributes:
10883 
   - warehouseId
10884 
  """
10885 
 
10886 
  thrift_spec = (
10887 
    None, # 0
10888 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10889 
  )
10890 
 
10891 
  def __init__(self, warehouseId=None,):
10892 
    self.warehouseId = warehouseId
10893 
 
10894 
  def read(self, iprot):
10895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10897 
      return
10898 
    iprot.readStructBegin()
10899 
    while True:
10900 
      (fname, ftype, fid) = iprot.readFieldBegin()
10901 
      if ftype == TType.STOP:
10902 
        break
10903 
      if fid == 1:
10904 
        if ftype == TType.I64:
10905 
          self.warehouseId = iprot.readI64();
10906 
        else:
10907 
          iprot.skip(ftype)
10908 
      else:
10909 
        iprot.skip(ftype)
10910 
      iprot.readFieldEnd()
10911 
    iprot.readStructEnd()
10912 
 
10913 
  def write(self, oprot):
10914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10916 
      return
10917 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 10918 
    if self.warehouseId is not None:
1220 chandransh 10919 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10920 
      oprot.writeI64(self.warehouseId)
10921 
      oprot.writeFieldEnd()
10922 
    oprot.writeFieldStop()
10923 
    oprot.writeStructEnd()
10924 
 
3431 rajveer 10925 
  def validate(self):
10926 
    return
10927 
 
10928 
 
1220 chandransh 10929 
  def __repr__(self):
10930 
    L = ['%s=%r' % (key, value)
10931 
      for key, value in self.__dict__.iteritems()]
10932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10933 
 
10934 
  def __eq__(self, other):
10935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10936 
 
10937 
  def __ne__(self, other):
10938 
    return not (self == other)
10939 
 
10940 
class batchOrders_result:
10941 
  """
10942 
  Attributes:
10943 
   - success
10944 
   - ex
10945 
  """
10946 
 
10947 
  thrift_spec = (
10948 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10949 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10950 
  )
10951 
 
10952 
  def __init__(self, success=None, ex=None,):
10953 
    self.success = success
10954 
    self.ex = ex
10955 
 
10956 
  def read(self, iprot):
10957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10959 
      return
10960 
    iprot.readStructBegin()
10961 
    while True:
10962 
      (fname, ftype, fid) = iprot.readFieldBegin()
10963 
      if ftype == TType.STOP:
10964 
        break
10965 
      if fid == 0:
10966 
        if ftype == TType.LIST:
10967 
          self.success = []
5031 varun.gupt 10968 
          (_etype206, _size203) = iprot.readListBegin()
10969 
          for _i207 in xrange(_size203):
10970 
            _elem208 = Order()
10971 
            _elem208.read(iprot)
10972 
            self.success.append(_elem208)
1220 chandransh 10973 
          iprot.readListEnd()
10974 
        else:
10975 
          iprot.skip(ftype)
10976 
      elif fid == 1:
10977 
        if ftype == TType.STRUCT:
10978 
          self.ex = TransactionServiceException()
10979 
          self.ex.read(iprot)
10980 
        else:
10981 
          iprot.skip(ftype)
10982 
      else:
10983 
        iprot.skip(ftype)
10984 
      iprot.readFieldEnd()
10985 
    iprot.readStructEnd()
10986 
 
10987 
  def write(self, oprot):
10988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10990 
      return
10991 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 10992 
    if self.success is not None:
1220 chandransh 10993 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10994 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10995 
      for iter209 in self.success:
10996 
        iter209.write(oprot)
1220 chandransh 10997 
      oprot.writeListEnd()
10998 
      oprot.writeFieldEnd()
3431 rajveer 10999 
    if self.ex is not None:
1220 chandransh 11000 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11001 
      self.ex.write(oprot)
11002 
      oprot.writeFieldEnd()
11003 
    oprot.writeFieldStop()
11004 
    oprot.writeStructEnd()
11005 
 
3431 rajveer 11006 
  def validate(self):
11007 
    return
11008 
 
11009 
 
1220 chandransh 11010 
  def __repr__(self):
11011 
    L = ['%s=%r' % (key, value)
11012 
      for key, value in self.__dict__.iteritems()]
11013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11014 
 
11015 
  def __eq__(self, other):
11016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11017 
 
11018 
  def __ne__(self, other):
11019 
    return not (self == other)
11020 
 
1208 chandransh 11021 
class markOrderAsOutOfStock_args:
11022 
  """
11023 
  Attributes:
11024 
   - orderId
11025 
  """
11026 
 
11027 
  thrift_spec = (
11028 
    None, # 0
11029 
    (1, TType.I64, 'orderId', None, None, ), # 1
11030 
  )
11031 
 
11032 
  def __init__(self, orderId=None,):
11033 
    self.orderId = orderId
11034 
 
11035 
  def read(self, iprot):
11036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11038 
      return
11039 
    iprot.readStructBegin()
11040 
    while True:
11041 
      (fname, ftype, fid) = iprot.readFieldBegin()
11042 
      if ftype == TType.STOP:
11043 
        break
11044 
      if fid == 1:
11045 
        if ftype == TType.I64:
11046 
          self.orderId = iprot.readI64();
11047 
        else:
11048 
          iprot.skip(ftype)
11049 
      else:
11050 
        iprot.skip(ftype)
11051 
      iprot.readFieldEnd()
11052 
    iprot.readStructEnd()
11053 
 
11054 
  def write(self, oprot):
11055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11057 
      return
11058 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 11059 
    if self.orderId is not None:
1208 chandransh 11060 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11061 
      oprot.writeI64(self.orderId)
11062 
      oprot.writeFieldEnd()
11063 
    oprot.writeFieldStop()
11064 
    oprot.writeStructEnd()
11065 
 
3431 rajveer 11066 
  def validate(self):
11067 
    return
11068 
 
11069 
 
1208 chandransh 11070 
  def __repr__(self):
11071 
    L = ['%s=%r' % (key, value)
11072 
      for key, value in self.__dict__.iteritems()]
11073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11074 
 
11075 
  def __eq__(self, other):
11076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11077 
 
11078 
  def __ne__(self, other):
11079 
    return not (self == other)
11080 
 
11081 
class markOrderAsOutOfStock_result:
11082 
  """
11083 
  Attributes:
11084 
   - success
11085 
   - ex
11086 
  """
11087 
 
11088 
  thrift_spec = (
11089 
    (0, TType.BOOL, 'success', None, None, ), # 0
11090 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11091 
  )
11092 
 
11093 
  def __init__(self, success=None, ex=None,):
11094 
    self.success = success
11095 
    self.ex = ex
11096 
 
11097 
  def read(self, iprot):
11098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11100 
      return
11101 
    iprot.readStructBegin()
11102 
    while True:
11103 
      (fname, ftype, fid) = iprot.readFieldBegin()
11104 
      if ftype == TType.STOP:
11105 
        break
11106 
      if fid == 0:
11107 
        if ftype == TType.BOOL:
11108 
          self.success = iprot.readBool();
11109 
        else:
11110 
          iprot.skip(ftype)
11111 
      elif fid == 1:
11112 
        if ftype == TType.STRUCT:
11113 
          self.ex = TransactionServiceException()
11114 
          self.ex.read(iprot)
11115 
        else:
11116 
          iprot.skip(ftype)
11117 
      else:
11118 
        iprot.skip(ftype)
11119 
      iprot.readFieldEnd()
11120 
    iprot.readStructEnd()
11121 
 
11122 
  def write(self, oprot):
11123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11125 
      return
11126 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 11127 
    if self.success is not None:
1208 chandransh 11128 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11129 
      oprot.writeBool(self.success)
11130 
      oprot.writeFieldEnd()
3431 rajveer 11131 
    if self.ex is not None:
1208 chandransh 11132 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11133 
      self.ex.write(oprot)
11134 
      oprot.writeFieldEnd()
11135 
    oprot.writeFieldStop()
11136 
    oprot.writeStructEnd()
11137 
 
3431 rajveer 11138 
  def validate(self):
11139 
    return
11140 
 
11141 
 
1208 chandransh 11142 
  def __repr__(self):
11143 
    L = ['%s=%r' % (key, value)
11144 
      for key, value in self.__dict__.iteritems()]
11145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11146 
 
11147 
  def __eq__(self, other):
11148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11149 
 
11150 
  def __ne__(self, other):
11151 
    return not (self == other)
11152 
 
3064 chandransh 11153 
class verifyOrder_args:
759 chandransh 11154 
  """
11155 
  Attributes:
3064 chandransh 11156 
   - orderId
759 chandransh 11157 
  """
11158 
 
11159 
  thrift_spec = (
11160 
    None, # 0
3064 chandransh 11161 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 11162 
  )
11163 
 
3064 chandransh 11164 
  def __init__(self, orderId=None,):
11165 
    self.orderId = orderId
759 chandransh 11166 
 
11167 
  def read(self, iprot):
11168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11170 
      return
11171 
    iprot.readStructBegin()
11172 
    while True:
11173 
      (fname, ftype, fid) = iprot.readFieldBegin()
11174 
      if ftype == TType.STOP:
11175 
        break
11176 
      if fid == 1:
11177 
        if ftype == TType.I64:
3064 chandransh 11178 
          self.orderId = iprot.readI64();
759 chandransh 11179 
        else:
11180 
          iprot.skip(ftype)
11181 
      else:
11182 
        iprot.skip(ftype)
11183 
      iprot.readFieldEnd()
11184 
    iprot.readStructEnd()
11185 
 
11186 
  def write(self, oprot):
11187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11189 
      return
3064 chandransh 11190 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 11191 
    if self.orderId is not None:
3064 chandransh 11192 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11193 
      oprot.writeI64(self.orderId)
759 chandransh 11194 
      oprot.writeFieldEnd()
11195 
    oprot.writeFieldStop()
11196 
    oprot.writeStructEnd()
11197 
 
3431 rajveer 11198 
  def validate(self):
11199 
    return
11200 
 
11201 
 
759 chandransh 11202 
  def __repr__(self):
11203 
    L = ['%s=%r' % (key, value)
11204 
      for key, value in self.__dict__.iteritems()]
11205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11206 
 
11207 
  def __eq__(self, other):
11208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11209 
 
11210 
  def __ne__(self, other):
11211 
    return not (self == other)
11212 
 
3064 chandransh 11213 
class verifyOrder_result:
759 chandransh 11214 
  """
11215 
  Attributes:
11216 
   - success
11217 
   - ex
11218 
  """
11219 
 
11220 
  thrift_spec = (
11221 
    (0, TType.BOOL, 'success', None, None, ), # 0
11222 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11223 
  )
11224 
 
11225 
  def __init__(self, success=None, ex=None,):
11226 
    self.success = success
11227 
    self.ex = ex
11228 
 
11229 
  def read(self, iprot):
11230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11232 
      return
11233 
    iprot.readStructBegin()
11234 
    while True:
11235 
      (fname, ftype, fid) = iprot.readFieldBegin()
11236 
      if ftype == TType.STOP:
11237 
        break
11238 
      if fid == 0:
11239 
        if ftype == TType.BOOL:
11240 
          self.success = iprot.readBool();
11241 
        else:
11242 
          iprot.skip(ftype)
11243 
      elif fid == 1:
11244 
        if ftype == TType.STRUCT:
11245 
          self.ex = TransactionServiceException()
11246 
          self.ex.read(iprot)
11247 
        else:
11248 
          iprot.skip(ftype)
11249 
      else:
11250 
        iprot.skip(ftype)
11251 
      iprot.readFieldEnd()
11252 
    iprot.readStructEnd()
11253 
 
11254 
  def write(self, oprot):
11255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11257 
      return
3064 chandransh 11258 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 11259 
    if self.success is not None:
759 chandransh 11260 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11261 
      oprot.writeBool(self.success)
11262 
      oprot.writeFieldEnd()
3431 rajveer 11263 
    if self.ex is not None:
759 chandransh 11264 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11265 
      self.ex.write(oprot)
11266 
      oprot.writeFieldEnd()
11267 
    oprot.writeFieldStop()
11268 
    oprot.writeStructEnd()
11269 
 
3431 rajveer 11270 
  def validate(self):
11271 
    return
11272 
 
11273 
 
759 chandransh 11274 
  def __repr__(self):
11275 
    L = ['%s=%r' % (key, value)
11276 
      for key, value in self.__dict__.iteritems()]
11277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11278 
 
11279 
  def __eq__(self, other):
11280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11281 
 
11282 
  def __ne__(self, other):
11283 
    return not (self == other)
11284 
 
3064 chandransh 11285 
class acceptOrder_args:
1113 chandransh 11286 
  """
11287 
  Attributes:
3064 chandransh 11288 
   - orderId
1113 chandransh 11289 
  """
11290 
 
11291 
  thrift_spec = (
11292 
    None, # 0
3064 chandransh 11293 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 11294 
  )
11295 
 
3064 chandransh 11296 
  def __init__(self, orderId=None,):
11297 
    self.orderId = orderId
1113 chandransh 11298 
 
11299 
  def read(self, iprot):
11300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11302 
      return
11303 
    iprot.readStructBegin()
11304 
    while True:
11305 
      (fname, ftype, fid) = iprot.readFieldBegin()
11306 
      if ftype == TType.STOP:
11307 
        break
11308 
      if fid == 1:
11309 
        if ftype == TType.I64:
3064 chandransh 11310 
          self.orderId = iprot.readI64();
1113 chandransh 11311 
        else:
11312 
          iprot.skip(ftype)
11313 
      else:
11314 
        iprot.skip(ftype)
11315 
      iprot.readFieldEnd()
11316 
    iprot.readStructEnd()
11317 
 
11318 
  def write(self, oprot):
11319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11321 
      return
3064 chandransh 11322 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 11323 
    if self.orderId is not None:
3064 chandransh 11324 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11325 
      oprot.writeI64(self.orderId)
1113 chandransh 11326 
      oprot.writeFieldEnd()
11327 
    oprot.writeFieldStop()
11328 
    oprot.writeStructEnd()
11329 
 
3431 rajveer 11330 
  def validate(self):
11331 
    return
11332 
 
11333 
 
1113 chandransh 11334 
  def __repr__(self):
11335 
    L = ['%s=%r' % (key, value)
11336 
      for key, value in self.__dict__.iteritems()]
11337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11338 
 
11339 
  def __eq__(self, other):
11340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11341 
 
11342 
  def __ne__(self, other):
11343 
    return not (self == other)
11344 
 
3064 chandransh 11345 
class acceptOrder_result:
1113 chandransh 11346 
  """
11347 
  Attributes:
11348 
   - success
11349 
   - ex
11350 
  """
11351 
 
11352 
  thrift_spec = (
3064 chandransh 11353 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 11354 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11355 
  )
11356 
 
11357 
  def __init__(self, success=None, ex=None,):
11358 
    self.success = success
11359 
    self.ex = ex
11360 
 
11361 
  def read(self, iprot):
11362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11364 
      return
11365 
    iprot.readStructBegin()
11366 
    while True:
11367 
      (fname, ftype, fid) = iprot.readFieldBegin()
11368 
      if ftype == TType.STOP:
11369 
        break
11370 
      if fid == 0:
3064 chandransh 11371 
        if ftype == TType.BOOL:
11372 
          self.success = iprot.readBool();
1113 chandransh 11373 
        else:
11374 
          iprot.skip(ftype)
11375 
      elif fid == 1:
11376 
        if ftype == TType.STRUCT:
11377 
          self.ex = TransactionServiceException()
11378 
          self.ex.read(iprot)
11379 
        else:
11380 
          iprot.skip(ftype)
11381 
      else:
11382 
        iprot.skip(ftype)
11383 
      iprot.readFieldEnd()
11384 
    iprot.readStructEnd()
11385 
 
11386 
  def write(self, oprot):
11387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11389 
      return
3064 chandransh 11390 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 11391 
    if self.success is not None:
3064 chandransh 11392 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11393 
      oprot.writeBool(self.success)
1113 chandransh 11394 
      oprot.writeFieldEnd()
3431 rajveer 11395 
    if self.ex is not None:
1113 chandransh 11396 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11397 
      self.ex.write(oprot)
11398 
      oprot.writeFieldEnd()
11399 
    oprot.writeFieldStop()
11400 
    oprot.writeStructEnd()
11401 
 
3431 rajveer 11402 
  def validate(self):
11403 
    return
11404 
 
11405 
 
1113 chandransh 11406 
  def __repr__(self):
11407 
    L = ['%s=%r' % (key, value)
11408 
      for key, value in self.__dict__.iteritems()]
11409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11410 
 
11411 
  def __eq__(self, other):
11412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11413 
 
11414 
  def __ne__(self, other):
11415 
    return not (self == other)
11416 
 
3064 chandransh 11417 
class addBillingDetails_args:
1135 chandransh 11418 
  """
11419 
  Attributes:
3064 chandransh 11420 
   - orderId
11421 
   - invoice_number
4658 mandeep.dh 11422 
   - serialNumber
4283 anupam.sin 11423 
   - itemNumber
3064 chandransh 11424 
   - billed_by
4264 rajveer 11425 
   - jacketNumber
4283 anupam.sin 11426 
   - billingType
5110 mandeep.dh 11427 
   - fulfilmentWarehouseId
4763 rajveer 11428 
   - authorize
1135 chandransh 11429 
  """
11430 
 
11431 
  thrift_spec = (
11432 
    None, # 0
3064 chandransh 11433 
    (1, TType.I64, 'orderId', None, None, ), # 1
11434 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 11435 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 11436 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
11437 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
11438 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
11439 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 11440 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 11441 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 11442 
  )
11443 
 
5110 mandeep.dh 11444 
  def __init__(self, orderId=None, invoice_number=None, serialNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, fulfilmentWarehouseId=None, authorize=None,):
3064 chandransh 11445 
    self.orderId = orderId
11446 
    self.invoice_number = invoice_number
4658 mandeep.dh 11447 
    self.serialNumber = serialNumber
4283 anupam.sin 11448 
    self.itemNumber = itemNumber
3064 chandransh 11449 
    self.billed_by = billed_by
4264 rajveer 11450 
    self.jacketNumber = jacketNumber
4283 anupam.sin 11451 
    self.billingType = billingType
5110 mandeep.dh 11452 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 11453 
    self.authorize = authorize
1135 chandransh 11454 
 
11455 
  def read(self, iprot):
11456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11458 
      return
11459 
    iprot.readStructBegin()
11460 
    while True:
11461 
      (fname, ftype, fid) = iprot.readFieldBegin()
11462 
      if ftype == TType.STOP:
11463 
        break
11464 
      if fid == 1:
11465 
        if ftype == TType.I64:
3064 chandransh 11466 
          self.orderId = iprot.readI64();
1135 chandransh 11467 
        else:
11468 
          iprot.skip(ftype)
11469 
      elif fid == 2:
3064 chandransh 11470 
        if ftype == TType.STRING:
11471 
          self.invoice_number = iprot.readString();
1135 chandransh 11472 
        else:
11473 
          iprot.skip(ftype)
3064 chandransh 11474 
      elif fid == 3:
4658 mandeep.dh 11475 
        if ftype == TType.STRING:
11476 
          self.serialNumber = iprot.readString();
3064 chandransh 11477 
        else:
11478 
          iprot.skip(ftype)
11479 
      elif fid == 4:
11480 
        if ftype == TType.STRING:
11481 
          self.itemNumber = iprot.readString();
11482 
        else:
11483 
          iprot.skip(ftype)
11484 
      elif fid == 5:
11485 
        if ftype == TType.STRING:
4283 anupam.sin 11486 
          self.billed_by = iprot.readString();
3064 chandransh 11487 
        else:
11488 
          iprot.skip(ftype)
11489 
      elif fid == 6:
11490 
        if ftype == TType.I64:
4283 anupam.sin 11491 
          self.jacketNumber = iprot.readI64();
11492 
        else:
11493 
          iprot.skip(ftype)
11494 
      elif fid == 7:
11495 
        if ftype == TType.I64:
3064 chandransh 11496 
          self.billingType = iprot.readI64();
11497 
        else:
11498 
          iprot.skip(ftype)
4283 anupam.sin 11499 
      elif fid == 8:
11500 
        if ftype == TType.I64:
5110 mandeep.dh 11501 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 11502 
        else:
11503 
          iprot.skip(ftype)
4763 rajveer 11504 
      elif fid == 9:
11505 
        if ftype == TType.BOOL:
11506 
          self.authorize = iprot.readBool();
11507 
        else:
11508 
          iprot.skip(ftype)
1246 chandransh 11509 
      else:
11510 
        iprot.skip(ftype)
11511 
      iprot.readFieldEnd()
11512 
    iprot.readStructEnd()
11513 
 
11514 
  def write(self, oprot):
11515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11517 
      return
4283 anupam.sin 11518 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 11519 
    if self.orderId is not None:
3064 chandransh 11520 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11521 
      oprot.writeI64(self.orderId)
1246 chandransh 11522 
      oprot.writeFieldEnd()
4283 anupam.sin 11523 
    if self.invoice_number is not None:
11524 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
11525 
      oprot.writeString(self.invoice_number)
1246 chandransh 11526 
      oprot.writeFieldEnd()
4658 mandeep.dh 11527 
    if self.serialNumber is not None:
11528 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
11529 
      oprot.writeString(self.serialNumber)
3064 chandransh 11530 
      oprot.writeFieldEnd()
3431 rajveer 11531 
    if self.itemNumber is not None:
3064 chandransh 11532 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
11533 
      oprot.writeString(self.itemNumber)
11534 
      oprot.writeFieldEnd()
4283 anupam.sin 11535 
    if self.billed_by is not None:
11536 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
11537 
      oprot.writeString(self.billed_by)
3064 chandransh 11538 
      oprot.writeFieldEnd()
4283 anupam.sin 11539 
    if self.jacketNumber is not None:
11540 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
11541 
      oprot.writeI64(self.jacketNumber)
11542 
      oprot.writeFieldEnd()
3431 rajveer 11543 
    if self.billingType is not None:
4283 anupam.sin 11544 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 11545 
      oprot.writeI64(self.billingType)
11546 
      oprot.writeFieldEnd()
5110 mandeep.dh 11547 
    if self.fulfilmentWarehouseId is not None:
11548 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
11549 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 11550 
      oprot.writeFieldEnd()
4763 rajveer 11551 
    if self.authorize is not None:
11552 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
11553 
      oprot.writeBool(self.authorize)
11554 
      oprot.writeFieldEnd()
1246 chandransh 11555 
    oprot.writeFieldStop()
11556 
    oprot.writeStructEnd()
11557 
 
3431 rajveer 11558 
  def validate(self):
11559 
    return
11560 
 
11561 
 
1246 chandransh 11562 
  def __repr__(self):
11563 
    L = ['%s=%r' % (key, value)
11564 
      for key, value in self.__dict__.iteritems()]
11565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11566 
 
11567 
  def __eq__(self, other):
11568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11569 
 
11570 
  def __ne__(self, other):
11571 
    return not (self == other)
11572 
 
4283 anupam.sin 11573 
class addBillingDetails_result:
1246 chandransh 11574 
  """
11575 
  Attributes:
3064 chandransh 11576 
   - success
1246 chandransh 11577 
   - ex
11578 
  """
11579 
 
11580 
  thrift_spec = (
3064 chandransh 11581 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 11582 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11583 
  )
11584 
 
3064 chandransh 11585 
  def __init__(self, success=None, ex=None,):
11586 
    self.success = success
1246 chandransh 11587 
    self.ex = ex
11588 
 
11589 
  def read(self, iprot):
11590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11592 
      return
11593 
    iprot.readStructBegin()
11594 
    while True:
11595 
      (fname, ftype, fid) = iprot.readFieldBegin()
11596 
      if ftype == TType.STOP:
11597 
        break
3064 chandransh 11598 
      if fid == 0:
11599 
        if ftype == TType.BOOL:
11600 
          self.success = iprot.readBool();
11601 
        else:
11602 
          iprot.skip(ftype)
11603 
      elif fid == 1:
1246 chandransh 11604 
        if ftype == TType.STRUCT:
11605 
          self.ex = TransactionServiceException()
11606 
          self.ex.read(iprot)
11607 
        else:
11608 
          iprot.skip(ftype)
11609 
      else:
11610 
        iprot.skip(ftype)
11611 
      iprot.readFieldEnd()
11612 
    iprot.readStructEnd()
11613 
 
11614 
  def write(self, oprot):
11615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11617 
      return
4283 anupam.sin 11618 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 11619 
    if self.success is not None:
3064 chandransh 11620 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11621 
      oprot.writeBool(self.success)
11622 
      oprot.writeFieldEnd()
3431 rajveer 11623 
    if self.ex is not None:
1246 chandransh 11624 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11625 
      self.ex.write(oprot)
11626 
      oprot.writeFieldEnd()
11627 
    oprot.writeFieldStop()
11628 
    oprot.writeStructEnd()
11629 
 
3431 rajveer 11630 
  def validate(self):
11631 
    return
11632 
 
11633 
 
1246 chandransh 11634 
  def __repr__(self):
11635 
    L = ['%s=%r' % (key, value)
11636 
      for key, value in self.__dict__.iteritems()]
11637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11638 
 
11639 
  def __eq__(self, other):
11640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11641 
 
11642 
  def __ne__(self, other):
11643 
    return not (self == other)
11644 
 
4579 rajveer 11645 
class addInvoiceNumber_args:
11646 
  """
11647 
  Attributes:
11648 
   - orderId
11649 
   - invoiceNumber
4763 rajveer 11650 
   - color
4579 rajveer 11651 
  """
11652 
 
11653 
  thrift_spec = (
11654 
    None, # 0
11655 
    (1, TType.I64, 'orderId', None, None, ), # 1
11656 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 11657 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 11658 
  )
11659 
 
4763 rajveer 11660 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 11661 
    self.orderId = orderId
11662 
    self.invoiceNumber = invoiceNumber
4763 rajveer 11663 
    self.color = color
4579 rajveer 11664 
 
11665 
  def read(self, iprot):
11666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11668 
      return
11669 
    iprot.readStructBegin()
11670 
    while True:
11671 
      (fname, ftype, fid) = iprot.readFieldBegin()
11672 
      if ftype == TType.STOP:
11673 
        break
11674 
      if fid == 1:
11675 
        if ftype == TType.I64:
11676 
          self.orderId = iprot.readI64();
11677 
        else:
11678 
          iprot.skip(ftype)
11679 
      elif fid == 2:
11680 
        if ftype == TType.STRING:
11681 
          self.invoiceNumber = iprot.readString();
11682 
        else:
11683 
          iprot.skip(ftype)
4763 rajveer 11684 
      elif fid == 3:
11685 
        if ftype == TType.STRING:
11686 
          self.color = iprot.readString();
11687 
        else:
11688 
          iprot.skip(ftype)
4579 rajveer 11689 
      else:
11690 
        iprot.skip(ftype)
11691 
      iprot.readFieldEnd()
11692 
    iprot.readStructEnd()
11693 
 
11694 
  def write(self, oprot):
11695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11697 
      return
11698 
    oprot.writeStructBegin('addInvoiceNumber_args')
11699 
    if self.orderId is not None:
11700 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11701 
      oprot.writeI64(self.orderId)
11702 
      oprot.writeFieldEnd()
11703 
    if self.invoiceNumber is not None:
11704 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
11705 
      oprot.writeString(self.invoiceNumber)
11706 
      oprot.writeFieldEnd()
4763 rajveer 11707 
    if self.color is not None:
11708 
      oprot.writeFieldBegin('color', TType.STRING, 3)
11709 
      oprot.writeString(self.color)
11710 
      oprot.writeFieldEnd()
4579 rajveer 11711 
    oprot.writeFieldStop()
11712 
    oprot.writeStructEnd()
11713 
 
11714 
  def validate(self):
11715 
    return
11716 
 
11717 
 
11718 
  def __repr__(self):
11719 
    L = ['%s=%r' % (key, value)
11720 
      for key, value in self.__dict__.iteritems()]
11721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11722 
 
11723 
  def __eq__(self, other):
11724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11725 
 
11726 
  def __ne__(self, other):
11727 
    return not (self == other)
11728 
 
11729 
class addInvoiceNumber_result:
11730 
  """
11731 
  Attributes:
11732 
   - ex
11733 
  """
11734 
 
11735 
  thrift_spec = (
11736 
    None, # 0
11737 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11738 
  )
11739 
 
11740 
  def __init__(self, ex=None,):
11741 
    self.ex = ex
11742 
 
11743 
  def read(self, iprot):
11744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11746 
      return
11747 
    iprot.readStructBegin()
11748 
    while True:
11749 
      (fname, ftype, fid) = iprot.readFieldBegin()
11750 
      if ftype == TType.STOP:
11751 
        break
11752 
      if fid == 1:
11753 
        if ftype == TType.STRUCT:
11754 
          self.ex = TransactionServiceException()
11755 
          self.ex.read(iprot)
11756 
        else:
11757 
          iprot.skip(ftype)
11758 
      else:
11759 
        iprot.skip(ftype)
11760 
      iprot.readFieldEnd()
11761 
    iprot.readStructEnd()
11762 
 
11763 
  def write(self, oprot):
11764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11766 
      return
11767 
    oprot.writeStructBegin('addInvoiceNumber_result')
11768 
    if self.ex is not None:
11769 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11770 
      self.ex.write(oprot)
11771 
      oprot.writeFieldEnd()
11772 
    oprot.writeFieldStop()
11773 
    oprot.writeStructEnd()
11774 
 
11775 
  def validate(self):
11776 
    return
11777 
 
11778 
 
11779 
  def __repr__(self):
11780 
    L = ['%s=%r' % (key, value)
11781 
      for key, value in self.__dict__.iteritems()]
11782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11783 
 
11784 
  def __eq__(self, other):
11785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11786 
 
11787 
  def __ne__(self, other):
11788 
    return not (self == other)
11789 
 
4910 phani.kuma 11790 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 11791 
  """
11792 
  Attributes:
3064 chandransh 11793 
   - warehouseId
1408 ankur.sing 11794 
   - providerId
3064 chandransh 11795 
   - cod
4910 phani.kuma 11796 
   - orderIds
1408 ankur.sing 11797 
  """
11798 
 
11799 
  thrift_spec = (
11800 
    None, # 0
3064 chandransh 11801 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11802 
    (2, TType.I64, 'providerId', None, None, ), # 2
11803 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 11804 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 11805 
  )
11806 
 
4910 phani.kuma 11807 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 11808 
    self.warehouseId = warehouseId
1408 ankur.sing 11809 
    self.providerId = providerId
3064 chandransh 11810 
    self.cod = cod
4910 phani.kuma 11811 
    self.orderIds = orderIds
1408 ankur.sing 11812 
 
11813 
  def read(self, iprot):
11814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11816 
      return
11817 
    iprot.readStructBegin()
11818 
    while True:
11819 
      (fname, ftype, fid) = iprot.readFieldBegin()
11820 
      if ftype == TType.STOP:
11821 
        break
11822 
      if fid == 1:
11823 
        if ftype == TType.I64:
3064 chandransh 11824 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 11825 
        else:
11826 
          iprot.skip(ftype)
11827 
      elif fid == 2:
11828 
        if ftype == TType.I64:
3064 chandransh 11829 
          self.providerId = iprot.readI64();
1408 ankur.sing 11830 
        else:
11831 
          iprot.skip(ftype)
3064 chandransh 11832 
      elif fid == 3:
11833 
        if ftype == TType.BOOL:
11834 
          self.cod = iprot.readBool();
11835 
        else:
11836 
          iprot.skip(ftype)
4910 phani.kuma 11837 
      elif fid == 4:
11838 
        if ftype == TType.LIST:
11839 
          self.orderIds = []
5031 varun.gupt 11840 
          (_etype213, _size210) = iprot.readListBegin()
11841 
          for _i214 in xrange(_size210):
11842 
            _elem215 = iprot.readI64();
11843 
            self.orderIds.append(_elem215)
4910 phani.kuma 11844 
          iprot.readListEnd()
11845 
        else:
11846 
          iprot.skip(ftype)
1408 ankur.sing 11847 
      else:
11848 
        iprot.skip(ftype)
11849 
      iprot.readFieldEnd()
11850 
    iprot.readStructEnd()
11851 
 
11852 
  def write(self, oprot):
11853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11855 
      return
4910 phani.kuma 11856 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 11857 
    if self.warehouseId is not None:
3064 chandransh 11858 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11859 
      oprot.writeI64(self.warehouseId)
11860 
      oprot.writeFieldEnd()
3431 rajveer 11861 
    if self.providerId is not None:
3064 chandransh 11862 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 11863 
      oprot.writeI64(self.providerId)
11864 
      oprot.writeFieldEnd()
3431 rajveer 11865 
    if self.cod is not None:
3064 chandransh 11866 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
11867 
      oprot.writeBool(self.cod)
1408 ankur.sing 11868 
      oprot.writeFieldEnd()
4910 phani.kuma 11869 
    if self.orderIds is not None:
11870 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
11871 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5031 varun.gupt 11872 
      for iter216 in self.orderIds:
11873 
        oprot.writeI64(iter216)
4910 phani.kuma 11874 
      oprot.writeListEnd()
11875 
      oprot.writeFieldEnd()
1408 ankur.sing 11876 
    oprot.writeFieldStop()
11877 
    oprot.writeStructEnd()
11878 
 
3431 rajveer 11879 
  def validate(self):
11880 
    return
11881 
 
11882 
 
1408 ankur.sing 11883 
  def __repr__(self):
11884 
    L = ['%s=%r' % (key, value)
11885 
      for key, value in self.__dict__.iteritems()]
11886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11887 
 
11888 
  def __eq__(self, other):
11889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11890 
 
11891 
  def __ne__(self, other):
11892 
    return not (self == other)
11893 
 
4910 phani.kuma 11894 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 11895 
  """
11896 
  Attributes:
11897 
   - success
3064 chandransh 11898 
   - ex
1408 ankur.sing 11899 
  """
11900 
 
11901 
  thrift_spec = (
3064 chandransh 11902 
    (0, TType.BOOL, 'success', None, None, ), # 0
11903 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 11904 
  )
11905 
 
3064 chandransh 11906 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 11907 
    self.success = success
3064 chandransh 11908 
    self.ex = ex
1408 ankur.sing 11909 
 
11910 
  def read(self, iprot):
11911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11913 
      return
11914 
    iprot.readStructBegin()
11915 
    while True:
11916 
      (fname, ftype, fid) = iprot.readFieldBegin()
11917 
      if ftype == TType.STOP:
11918 
        break
11919 
      if fid == 0:
3064 chandransh 11920 
        if ftype == TType.BOOL:
11921 
          self.success = iprot.readBool();
1408 ankur.sing 11922 
        else:
11923 
          iprot.skip(ftype)
3064 chandransh 11924 
      elif fid == 1:
11925 
        if ftype == TType.STRUCT:
11926 
          self.ex = TransactionServiceException()
11927 
          self.ex.read(iprot)
11928 
        else:
11929 
          iprot.skip(ftype)
1408 ankur.sing 11930 
      else:
11931 
        iprot.skip(ftype)
11932 
      iprot.readFieldEnd()
11933 
    iprot.readStructEnd()
11934 
 
11935 
  def write(self, oprot):
11936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11938 
      return
4910 phani.kuma 11939 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 11940 
    if self.success is not None:
3064 chandransh 11941 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11942 
      oprot.writeBool(self.success)
1408 ankur.sing 11943 
      oprot.writeFieldEnd()
3431 rajveer 11944 
    if self.ex is not None:
3064 chandransh 11945 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11946 
      self.ex.write(oprot)
11947 
      oprot.writeFieldEnd()
1408 ankur.sing 11948 
    oprot.writeFieldStop()
11949 
    oprot.writeStructEnd()
11950 
 
3431 rajveer 11951 
  def validate(self):
11952 
    return
11953 
 
11954 
 
1408 ankur.sing 11955 
  def __repr__(self):
11956 
    L = ['%s=%r' % (key, value)
11957 
      for key, value in self.__dict__.iteritems()]
11958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11959 
 
11960 
  def __eq__(self, other):
11961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11962 
 
11963 
  def __ne__(self, other):
11964 
    return not (self == other)
11965 
 
4910 phani.kuma 11966 
class markOrdersAsPickedUp_args:
4410 rajveer 11967 
  """
11968 
  Attributes:
11969 
   - providerId
4910 phani.kuma 11970 
   - pickupDetails
4410 rajveer 11971 
  """
11972 
 
11973 
  thrift_spec = (
11974 
    None, # 0
4910 phani.kuma 11975 
    (1, TType.I64, 'providerId', None, None, ), # 1
11976 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 11977 
  )
11978 
 
4910 phani.kuma 11979 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 11980 
    self.providerId = providerId
4910 phani.kuma 11981 
    self.pickupDetails = pickupDetails
4410 rajveer 11982 
 
11983 
  def read(self, iprot):
11984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11986 
      return
11987 
    iprot.readStructBegin()
11988 
    while True:
11989 
      (fname, ftype, fid) = iprot.readFieldBegin()
11990 
      if ftype == TType.STOP:
11991 
        break
11992 
      if fid == 1:
11993 
        if ftype == TType.I64:
4910 phani.kuma 11994 
          self.providerId = iprot.readI64();
4410 rajveer 11995 
        else:
11996 
          iprot.skip(ftype)
11997 
      elif fid == 2:
4910 phani.kuma 11998 
        if ftype == TType.MAP:
11999 
          self.pickupDetails = {}
5031 varun.gupt 12000 
          (_ktype218, _vtype219, _size217 ) = iprot.readMapBegin()
12001 
          for _i221 in xrange(_size217):
12002 
            _key222 = iprot.readString();
12003 
            _val223 = iprot.readString();
12004 
            self.pickupDetails[_key222] = _val223
4910 phani.kuma 12005 
          iprot.readMapEnd()
4410 rajveer 12006 
        else:
12007 
          iprot.skip(ftype)
12008 
      else:
12009 
        iprot.skip(ftype)
12010 
      iprot.readFieldEnd()
12011 
    iprot.readStructEnd()
12012 
 
12013 
  def write(self, oprot):
12014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12016 
      return
4910 phani.kuma 12017 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 12018 
    if self.providerId is not None:
4910 phani.kuma 12019 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 12020 
      oprot.writeI64(self.providerId)
12021 
      oprot.writeFieldEnd()
4910 phani.kuma 12022 
    if self.pickupDetails is not None:
12023 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
12024 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 12025 
      for kiter224,viter225 in self.pickupDetails.items():
12026 
        oprot.writeString(kiter224)
12027 
        oprot.writeString(viter225)
4910 phani.kuma 12028 
      oprot.writeMapEnd()
4410 rajveer 12029 
      oprot.writeFieldEnd()
12030 
    oprot.writeFieldStop()
12031 
    oprot.writeStructEnd()
12032 
 
12033 
  def validate(self):
12034 
    return
12035 
 
12036 
 
12037 
  def __repr__(self):
12038 
    L = ['%s=%r' % (key, value)
12039 
      for key, value in self.__dict__.iteritems()]
12040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12041 
 
12042 
  def __eq__(self, other):
12043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12044 
 
12045 
  def __ne__(self, other):
12046 
    return not (self == other)
12047 
 
4910 phani.kuma 12048 
class markOrdersAsPickedUp_result:
4410 rajveer 12049 
  """
12050 
  Attributes:
12051 
   - ex
12052 
  """
12053 
 
12054 
  thrift_spec = (
4910 phani.kuma 12055 
    None, # 0
4410 rajveer 12056 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12057 
  )
12058 
 
4910 phani.kuma 12059 
  def __init__(self, ex=None,):
4410 rajveer 12060 
    self.ex = ex
12061 
 
12062 
  def read(self, iprot):
12063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12065 
      return
12066 
    iprot.readStructBegin()
12067 
    while True:
12068 
      (fname, ftype, fid) = iprot.readFieldBegin()
12069 
      if ftype == TType.STOP:
12070 
        break
4910 phani.kuma 12071 
      if fid == 1:
4410 rajveer 12072 
        if ftype == TType.STRUCT:
12073 
          self.ex = TransactionServiceException()
12074 
          self.ex.read(iprot)
12075 
        else:
12076 
          iprot.skip(ftype)
12077 
      else:
12078 
        iprot.skip(ftype)
12079 
      iprot.readFieldEnd()
12080 
    iprot.readStructEnd()
12081 
 
12082 
  def write(self, oprot):
12083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12085 
      return
4910 phani.kuma 12086 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 12087 
    if self.ex is not None:
12088 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12089 
      self.ex.write(oprot)
12090 
      oprot.writeFieldEnd()
12091 
    oprot.writeFieldStop()
12092 
    oprot.writeStructEnd()
12093 
 
12094 
  def validate(self):
12095 
    return
12096 
 
12097 
 
12098 
  def __repr__(self):
12099 
    L = ['%s=%r' % (key, value)
12100 
      for key, value in self.__dict__.iteritems()]
12101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12102 
 
12103 
  def __eq__(self, other):
12104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12105 
 
12106 
  def __ne__(self, other):
12107 
    return not (self == other)
12108 
 
4910 phani.kuma 12109 
class getOrdersNotPickedUp_args:
304 ashish 12110 
  """
12111 
  Attributes:
3064 chandransh 12112 
   - providerId
304 ashish 12113 
  """
94 ashish 12114 
 
304 ashish 12115 
  thrift_spec = (
12116 
    None, # 0
3064 chandransh 12117 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 12118 
  )
12119 
 
4910 phani.kuma 12120 
  def __init__(self, providerId=None,):
3064 chandransh 12121 
    self.providerId = providerId
304 ashish 12122 
 
12123 
  def read(self, iprot):
12124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12126 
      return
12127 
    iprot.readStructBegin()
12128 
    while True:
12129 
      (fname, ftype, fid) = iprot.readFieldBegin()
12130 
      if ftype == TType.STOP:
12131 
        break
12132 
      if fid == 1:
12133 
        if ftype == TType.I64:
3064 chandransh 12134 
          self.providerId = iprot.readI64();
304 ashish 12135 
        else:
12136 
          iprot.skip(ftype)
12137 
      else:
12138 
        iprot.skip(ftype)
12139 
      iprot.readFieldEnd()
12140 
    iprot.readStructEnd()
12141 
 
12142 
  def write(self, oprot):
12143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12145 
      return
4910 phani.kuma 12146 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 12147 
    if self.providerId is not None:
3064 chandransh 12148 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12149 
      oprot.writeI64(self.providerId)
304 ashish 12150 
      oprot.writeFieldEnd()
12151 
    oprot.writeFieldStop()
12152 
    oprot.writeStructEnd()
12153 
 
3431 rajveer 12154 
  def validate(self):
12155 
    return
12156 
 
12157 
 
304 ashish 12158 
  def __repr__(self):
12159 
    L = ['%s=%r' % (key, value)
12160 
      for key, value in self.__dict__.iteritems()]
12161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12162 
 
12163 
  def __eq__(self, other):
12164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12165 
 
12166 
  def __ne__(self, other):
12167 
    return not (self == other)
12168 
 
4910 phani.kuma 12169 
class getOrdersNotPickedUp_result:
304 ashish 12170 
  """
12171 
  Attributes:
12172 
   - success
12173 
  """
12174 
 
12175 
  thrift_spec = (
3064 chandransh 12176 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 12177 
  )
12178 
 
4910 phani.kuma 12179 
  def __init__(self, success=None,):
304 ashish 12180 
    self.success = success
12181 
 
12182 
  def read(self, iprot):
12183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12185 
      return
12186 
    iprot.readStructBegin()
12187 
    while True:
12188 
      (fname, ftype, fid) = iprot.readFieldBegin()
12189 
      if ftype == TType.STOP:
12190 
        break
12191 
      if fid == 0:
12192 
        if ftype == TType.LIST:
12193 
          self.success = []
5031 varun.gupt 12194 
          (_etype229, _size226) = iprot.readListBegin()
12195 
          for _i230 in xrange(_size226):
12196 
            _elem231 = Order()
12197 
            _elem231.read(iprot)
12198 
            self.success.append(_elem231)
304 ashish 12199 
          iprot.readListEnd()
12200 
        else:
12201 
          iprot.skip(ftype)
12202 
      else:
12203 
        iprot.skip(ftype)
12204 
      iprot.readFieldEnd()
12205 
    iprot.readStructEnd()
12206 
 
12207 
  def write(self, oprot):
12208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12210 
      return
4910 phani.kuma 12211 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 12212 
    if self.success is not None:
304 ashish 12213 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12214 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12215 
      for iter232 in self.success:
12216 
        iter232.write(oprot)
304 ashish 12217 
      oprot.writeListEnd()
12218 
      oprot.writeFieldEnd()
12219 
    oprot.writeFieldStop()
12220 
    oprot.writeStructEnd()
12221 
 
3431 rajveer 12222 
  def validate(self):
12223 
    return
12224 
 
12225 
 
304 ashish 12226 
  def __repr__(self):
12227 
    L = ['%s=%r' % (key, value)
12228 
      for key, value in self.__dict__.iteritems()]
12229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12230 
 
12231 
  def __eq__(self, other):
12232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12233 
 
12234 
  def __ne__(self, other):
12235 
    return not (self == other)
12236 
 
3064 chandransh 12237 
class markOrdersAsDelivered_args:
304 ashish 12238 
  """
12239 
  Attributes:
3064 chandransh 12240 
   - providerId
12241 
   - deliveredOrders
304 ashish 12242 
  """
12243 
 
12244 
  thrift_spec = (
12245 
    None, # 0
3064 chandransh 12246 
    (1, TType.I64, 'providerId', None, None, ), # 1
12247 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 12248 
  )
12249 
 
3064 chandransh 12250 
  def __init__(self, providerId=None, deliveredOrders=None,):
12251 
    self.providerId = providerId
12252 
    self.deliveredOrders = deliveredOrders
304 ashish 12253 
 
12254 
  def read(self, iprot):
12255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12257 
      return
12258 
    iprot.readStructBegin()
12259 
    while True:
12260 
      (fname, ftype, fid) = iprot.readFieldBegin()
12261 
      if ftype == TType.STOP:
12262 
        break
12263 
      if fid == 1:
12264 
        if ftype == TType.I64:
3064 chandransh 12265 
          self.providerId = iprot.readI64();
304 ashish 12266 
        else:
12267 
          iprot.skip(ftype)
12268 
      elif fid == 2:
3064 chandransh 12269 
        if ftype == TType.MAP:
12270 
          self.deliveredOrders = {}
5031 varun.gupt 12271 
          (_ktype234, _vtype235, _size233 ) = iprot.readMapBegin()
12272 
          for _i237 in xrange(_size233):
12273 
            _key238 = iprot.readString();
12274 
            _val239 = iprot.readString();
12275 
            self.deliveredOrders[_key238] = _val239
3064 chandransh 12276 
          iprot.readMapEnd()
304 ashish 12277 
        else:
12278 
          iprot.skip(ftype)
12279 
      else:
12280 
        iprot.skip(ftype)
12281 
      iprot.readFieldEnd()
12282 
    iprot.readStructEnd()
12283 
 
12284 
  def write(self, oprot):
12285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12287 
      return
3064 chandransh 12288 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 12289 
    if self.providerId is not None:
3064 chandransh 12290 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12291 
      oprot.writeI64(self.providerId)
304 ashish 12292 
      oprot.writeFieldEnd()
3431 rajveer 12293 
    if self.deliveredOrders is not None:
3064 chandransh 12294 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
12295 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
5031 varun.gupt 12296 
      for kiter240,viter241 in self.deliveredOrders.items():
12297 
        oprot.writeString(kiter240)
12298 
        oprot.writeString(viter241)
3064 chandransh 12299 
      oprot.writeMapEnd()
304 ashish 12300 
      oprot.writeFieldEnd()
12301 
    oprot.writeFieldStop()
12302 
    oprot.writeStructEnd()
12303 
 
3431 rajveer 12304 
  def validate(self):
12305 
    return
12306 
 
12307 
 
304 ashish 12308 
  def __repr__(self):
12309 
    L = ['%s=%r' % (key, value)
12310 
      for key, value in self.__dict__.iteritems()]
12311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12312 
 
12313 
  def __eq__(self, other):
12314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12315 
 
12316 
  def __ne__(self, other):
12317 
    return not (self == other)
12318 
 
3064 chandransh 12319 
class markOrdersAsDelivered_result:
12320 
  """
12321 
  Attributes:
12322 
   - ex
12323 
  """
304 ashish 12324 
 
12325 
  thrift_spec = (
3064 chandransh 12326 
    None, # 0
12327 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 12328 
  )
12329 
 
3064 chandransh 12330 
  def __init__(self, ex=None,):
12331 
    self.ex = ex
304 ashish 12332 
 
1596 ankur.sing 12333 
  def read(self, iprot):
12334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12336 
      return
12337 
    iprot.readStructBegin()
12338 
    while True:
12339 
      (fname, ftype, fid) = iprot.readFieldBegin()
12340 
      if ftype == TType.STOP:
12341 
        break
3064 chandransh 12342 
      if fid == 1:
12343 
        if ftype == TType.STRUCT:
12344 
          self.ex = TransactionServiceException()
12345 
          self.ex.read(iprot)
12346 
        else:
12347 
          iprot.skip(ftype)
1596 ankur.sing 12348 
      else:
12349 
        iprot.skip(ftype)
12350 
      iprot.readFieldEnd()
12351 
    iprot.readStructEnd()
12352 
 
12353 
  def write(self, oprot):
12354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12356 
      return
3064 chandransh 12357 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 12358 
    if self.ex is not None:
3064 chandransh 12359 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12360 
      self.ex.write(oprot)
12361 
      oprot.writeFieldEnd()
1596 ankur.sing 12362 
    oprot.writeFieldStop()
12363 
    oprot.writeStructEnd()
12364 
 
3431 rajveer 12365 
  def validate(self):
12366 
    return
12367 
 
12368 
 
1596 ankur.sing 12369 
  def __repr__(self):
12370 
    L = ['%s=%r' % (key, value)
12371 
      for key, value in self.__dict__.iteritems()]
12372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12373 
 
12374 
  def __eq__(self, other):
12375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12376 
 
12377 
  def __ne__(self, other):
12378 
    return not (self == other)
12379 
 
4910 phani.kuma 12380 
class markAsRTOrders_args:
1596 ankur.sing 12381 
  """
12382 
  Attributes:
3064 chandransh 12383 
   - providerId
12384 
   - returnedOrders
1596 ankur.sing 12385 
  """
12386 
 
12387 
  thrift_spec = (
3064 chandransh 12388 
    None, # 0
12389 
    (1, TType.I64, 'providerId', None, None, ), # 1
12390 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 12391 
  )
12392 
 
3064 chandransh 12393 
  def __init__(self, providerId=None, returnedOrders=None,):
12394 
    self.providerId = providerId
12395 
    self.returnedOrders = returnedOrders
1596 ankur.sing 12396 
 
12397 
  def read(self, iprot):
12398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12400 
      return
12401 
    iprot.readStructBegin()
12402 
    while True:
12403 
      (fname, ftype, fid) = iprot.readFieldBegin()
12404 
      if ftype == TType.STOP:
12405 
        break
3064 chandransh 12406 
      if fid == 1:
1596 ankur.sing 12407 
        if ftype == TType.I64:
3064 chandransh 12408 
          self.providerId = iprot.readI64();
1596 ankur.sing 12409 
        else:
12410 
          iprot.skip(ftype)
3064 chandransh 12411 
      elif fid == 2:
12412 
        if ftype == TType.MAP:
12413 
          self.returnedOrders = {}
5031 varun.gupt 12414 
          (_ktype243, _vtype244, _size242 ) = iprot.readMapBegin()
12415 
          for _i246 in xrange(_size242):
12416 
            _key247 = iprot.readString();
12417 
            _val248 = iprot.readString();
12418 
            self.returnedOrders[_key247] = _val248
3064 chandransh 12419 
          iprot.readMapEnd()
12420 
        else:
12421 
          iprot.skip(ftype)
1596 ankur.sing 12422 
      else:
12423 
        iprot.skip(ftype)
12424 
      iprot.readFieldEnd()
12425 
    iprot.readStructEnd()
12426 
 
12427 
  def write(self, oprot):
12428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12430 
      return
4910 phani.kuma 12431 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 12432 
    if self.providerId is not None:
3064 chandransh 12433 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12434 
      oprot.writeI64(self.providerId)
1596 ankur.sing 12435 
      oprot.writeFieldEnd()
3431 rajveer 12436 
    if self.returnedOrders is not None:
3064 chandransh 12437 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
12438 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
5031 varun.gupt 12439 
      for kiter249,viter250 in self.returnedOrders.items():
12440 
        oprot.writeString(kiter249)
12441 
        oprot.writeString(viter250)
3064 chandransh 12442 
      oprot.writeMapEnd()
12443 
      oprot.writeFieldEnd()
1596 ankur.sing 12444 
    oprot.writeFieldStop()
12445 
    oprot.writeStructEnd()
12446 
 
3431 rajveer 12447 
  def validate(self):
12448 
    return
12449 
 
12450 
 
1596 ankur.sing 12451 
  def __repr__(self):
12452 
    L = ['%s=%r' % (key, value)
12453 
      for key, value in self.__dict__.iteritems()]
12454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12455 
 
12456 
  def __eq__(self, other):
12457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12458 
 
12459 
  def __ne__(self, other):
12460 
    return not (self == other)
12461 
 
4910 phani.kuma 12462 
class markAsRTOrders_result:
3064 chandransh 12463 
  """
12464 
  Attributes:
12465 
   - ex
12466 
  """
1596 ankur.sing 12467 
 
1627 ankur.sing 12468 
  thrift_spec = (
3064 chandransh 12469 
    None, # 0
12470 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12471 
  )
12472 
 
3064 chandransh 12473 
  def __init__(self, ex=None,):
12474 
    self.ex = ex
12475 
 
1627 ankur.sing 12476 
  def read(self, iprot):
12477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12479 
      return
12480 
    iprot.readStructBegin()
12481 
    while True:
12482 
      (fname, ftype, fid) = iprot.readFieldBegin()
12483 
      if ftype == TType.STOP:
12484 
        break
3064 chandransh 12485 
      if fid == 1:
12486 
        if ftype == TType.STRUCT:
12487 
          self.ex = TransactionServiceException()
12488 
          self.ex.read(iprot)
12489 
        else:
12490 
          iprot.skip(ftype)
1627 ankur.sing 12491 
      else:
12492 
        iprot.skip(ftype)
12493 
      iprot.readFieldEnd()
12494 
    iprot.readStructEnd()
12495 
 
12496 
  def write(self, oprot):
12497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12499 
      return
4910 phani.kuma 12500 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 12501 
    if self.ex is not None:
3064 chandransh 12502 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12503 
      self.ex.write(oprot)
12504 
      oprot.writeFieldEnd()
1627 ankur.sing 12505 
    oprot.writeFieldStop()
12506 
    oprot.writeStructEnd()
12507 
 
3431 rajveer 12508 
  def validate(self):
12509 
    return
12510 
 
12511 
 
1627 ankur.sing 12512 
  def __repr__(self):
12513 
    L = ['%s=%r' % (key, value)
12514 
      for key, value in self.__dict__.iteritems()]
12515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12516 
 
12517 
  def __eq__(self, other):
12518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12519 
 
12520 
  def __ne__(self, other):
12521 
    return not (self == other)
12522 
 
4910 phani.kuma 12523 
class getRTOrders_args:
12524 
  """
12525 
  Attributes:
12526 
   - providerId
12527 
  """
12528 
 
12529 
  thrift_spec = (
12530 
    None, # 0
12531 
    (1, TType.I64, 'providerId', None, None, ), # 1
12532 
  )
12533 
 
12534 
  def __init__(self, providerId=None,):
12535 
    self.providerId = providerId
12536 
 
12537 
  def read(self, iprot):
12538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12540 
      return
12541 
    iprot.readStructBegin()
12542 
    while True:
12543 
      (fname, ftype, fid) = iprot.readFieldBegin()
12544 
      if ftype == TType.STOP:
12545 
        break
12546 
      if fid == 1:
12547 
        if ftype == TType.I64:
12548 
          self.providerId = iprot.readI64();
12549 
        else:
12550 
          iprot.skip(ftype)
12551 
      else:
12552 
        iprot.skip(ftype)
12553 
      iprot.readFieldEnd()
12554 
    iprot.readStructEnd()
12555 
 
12556 
  def write(self, oprot):
12557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12559 
      return
12560 
    oprot.writeStructBegin('getRTOrders_args')
12561 
    if self.providerId is not None:
12562 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12563 
      oprot.writeI64(self.providerId)
12564 
      oprot.writeFieldEnd()
12565 
    oprot.writeFieldStop()
12566 
    oprot.writeStructEnd()
12567 
 
12568 
  def validate(self):
12569 
    return
12570 
 
12571 
 
12572 
  def __repr__(self):
12573 
    L = ['%s=%r' % (key, value)
12574 
      for key, value in self.__dict__.iteritems()]
12575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12576 
 
12577 
  def __eq__(self, other):
12578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12579 
 
12580 
  def __ne__(self, other):
12581 
    return not (self == other)
12582 
 
12583 
class getRTOrders_result:
12584 
  """
12585 
  Attributes:
12586 
   - success
12587 
  """
12588 
 
12589 
  thrift_spec = (
12590 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12591 
  )
12592 
 
12593 
  def __init__(self, success=None,):
12594 
    self.success = success
12595 
 
12596 
  def read(self, iprot):
12597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12599 
      return
12600 
    iprot.readStructBegin()
12601 
    while True:
12602 
      (fname, ftype, fid) = iprot.readFieldBegin()
12603 
      if ftype == TType.STOP:
12604 
        break
12605 
      if fid == 0:
12606 
        if ftype == TType.LIST:
12607 
          self.success = []
5031 varun.gupt 12608 
          (_etype254, _size251) = iprot.readListBegin()
12609 
          for _i255 in xrange(_size251):
12610 
            _elem256 = Order()
12611 
            _elem256.read(iprot)
12612 
            self.success.append(_elem256)
4910 phani.kuma 12613 
          iprot.readListEnd()
12614 
        else:
12615 
          iprot.skip(ftype)
12616 
      else:
12617 
        iprot.skip(ftype)
12618 
      iprot.readFieldEnd()
12619 
    iprot.readStructEnd()
12620 
 
12621 
  def write(self, oprot):
12622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12624 
      return
12625 
    oprot.writeStructBegin('getRTOrders_result')
12626 
    if self.success is not None:
12627 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12628 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12629 
      for iter257 in self.success:
12630 
        iter257.write(oprot)
4910 phani.kuma 12631 
      oprot.writeListEnd()
12632 
      oprot.writeFieldEnd()
12633 
    oprot.writeFieldStop()
12634 
    oprot.writeStructEnd()
12635 
 
12636 
  def validate(self):
12637 
    return
12638 
 
12639 
 
12640 
  def __repr__(self):
12641 
    L = ['%s=%r' % (key, value)
12642 
      for key, value in self.__dict__.iteritems()]
12643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12644 
 
12645 
  def __eq__(self, other):
12646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12647 
 
12648 
  def __ne__(self, other):
12649 
    return not (self == other)
12650 
 
3064 chandransh 12651 
class updateNonDeliveryReason_args:
1627 ankur.sing 12652 
  """
12653 
  Attributes:
3064 chandransh 12654 
   - providerId
12655 
   - undeliveredOrders
1627 ankur.sing 12656 
  """
12657 
 
12658 
  thrift_spec = (
3064 chandransh 12659 
    None, # 0
12660 
    (1, TType.I64, 'providerId', None, None, ), # 1
12661 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 12662 
  )
12663 
 
3064 chandransh 12664 
  def __init__(self, providerId=None, undeliveredOrders=None,):
12665 
    self.providerId = providerId
12666 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 12667 
 
12668 
  def read(self, iprot):
12669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12671 
      return
12672 
    iprot.readStructBegin()
12673 
    while True:
12674 
      (fname, ftype, fid) = iprot.readFieldBegin()
12675 
      if ftype == TType.STOP:
12676 
        break
3064 chandransh 12677 
      if fid == 1:
1627 ankur.sing 12678 
        if ftype == TType.I64:
3064 chandransh 12679 
          self.providerId = iprot.readI64();
1627 ankur.sing 12680 
        else:
12681 
          iprot.skip(ftype)
3064 chandransh 12682 
      elif fid == 2:
12683 
        if ftype == TType.MAP:
12684 
          self.undeliveredOrders = {}
5031 varun.gupt 12685 
          (_ktype259, _vtype260, _size258 ) = iprot.readMapBegin()
12686 
          for _i262 in xrange(_size258):
12687 
            _key263 = iprot.readString();
12688 
            _val264 = iprot.readString();
12689 
            self.undeliveredOrders[_key263] = _val264
3064 chandransh 12690 
          iprot.readMapEnd()
12691 
        else:
12692 
          iprot.skip(ftype)
1627 ankur.sing 12693 
      else:
12694 
        iprot.skip(ftype)
12695 
      iprot.readFieldEnd()
12696 
    iprot.readStructEnd()
12697 
 
12698 
  def write(self, oprot):
12699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12701 
      return
3064 chandransh 12702 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 12703 
    if self.providerId is not None:
3064 chandransh 12704 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12705 
      oprot.writeI64(self.providerId)
1627 ankur.sing 12706 
      oprot.writeFieldEnd()
3431 rajveer 12707 
    if self.undeliveredOrders is not None:
3064 chandransh 12708 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
12709 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
5031 varun.gupt 12710 
      for kiter265,viter266 in self.undeliveredOrders.items():
12711 
        oprot.writeString(kiter265)
12712 
        oprot.writeString(viter266)
3064 chandransh 12713 
      oprot.writeMapEnd()
12714 
      oprot.writeFieldEnd()
1627 ankur.sing 12715 
    oprot.writeFieldStop()
12716 
    oprot.writeStructEnd()
12717 
 
3431 rajveer 12718 
  def validate(self):
12719 
    return
12720 
 
12721 
 
1627 ankur.sing 12722 
  def __repr__(self):
12723 
    L = ['%s=%r' % (key, value)
12724 
      for key, value in self.__dict__.iteritems()]
12725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12726 
 
12727 
  def __eq__(self, other):
12728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12729 
 
12730 
  def __ne__(self, other):
12731 
    return not (self == other)
12732 
 
3064 chandransh 12733 
class updateNonDeliveryReason_result:
1627 ankur.sing 12734 
  """
12735 
  Attributes:
3064 chandransh 12736 
   - ex
1627 ankur.sing 12737 
  """
12738 
 
12739 
  thrift_spec = (
4910 phani.kuma 12740 
    None, # 0
3064 chandransh 12741 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12742 
  )
12743 
 
4910 phani.kuma 12744 
  def __init__(self, ex=None,):
3064 chandransh 12745 
    self.ex = ex
1627 ankur.sing 12746 
 
12747 
  def read(self, iprot):
12748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12750 
      return
12751 
    iprot.readStructBegin()
12752 
    while True:
12753 
      (fname, ftype, fid) = iprot.readFieldBegin()
12754 
      if ftype == TType.STOP:
12755 
        break
4910 phani.kuma 12756 
      if fid == 1:
12757 
        if ftype == TType.STRUCT:
12758 
          self.ex = TransactionServiceException()
12759 
          self.ex.read(iprot)
12760 
        else:
12761 
          iprot.skip(ftype)
12762 
      else:
12763 
        iprot.skip(ftype)
12764 
      iprot.readFieldEnd()
12765 
    iprot.readStructEnd()
12766 
 
12767 
  def write(self, oprot):
12768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12770 
      return
12771 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
12772 
    if self.ex is not None:
12773 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12774 
      self.ex.write(oprot)
12775 
      oprot.writeFieldEnd()
12776 
    oprot.writeFieldStop()
12777 
    oprot.writeStructEnd()
12778 
 
12779 
  def validate(self):
12780 
    return
12781 
 
12782 
 
12783 
  def __repr__(self):
12784 
    L = ['%s=%r' % (key, value)
12785 
      for key, value in self.__dict__.iteritems()]
12786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12787 
 
12788 
  def __eq__(self, other):
12789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12790 
 
12791 
  def __ne__(self, other):
12792 
    return not (self == other)
12793 
 
12794 
class getNonDeliveredOrdersbyCourier_args:
12795 
  """
12796 
  Attributes:
12797 
   - providerId
12798 
  """
12799 
 
12800 
  thrift_spec = (
12801 
    None, # 0
12802 
    (1, TType.I64, 'providerId', None, None, ), # 1
12803 
  )
12804 
 
12805 
  def __init__(self, providerId=None,):
12806 
    self.providerId = providerId
12807 
 
12808 
  def read(self, iprot):
12809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12811 
      return
12812 
    iprot.readStructBegin()
12813 
    while True:
12814 
      (fname, ftype, fid) = iprot.readFieldBegin()
12815 
      if ftype == TType.STOP:
12816 
        break
12817 
      if fid == 1:
12818 
        if ftype == TType.I64:
12819 
          self.providerId = iprot.readI64();
12820 
        else:
12821 
          iprot.skip(ftype)
12822 
      else:
12823 
        iprot.skip(ftype)
12824 
      iprot.readFieldEnd()
12825 
    iprot.readStructEnd()
12826 
 
12827 
  def write(self, oprot):
12828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12830 
      return
12831 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
12832 
    if self.providerId is not None:
12833 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12834 
      oprot.writeI64(self.providerId)
12835 
      oprot.writeFieldEnd()
12836 
    oprot.writeFieldStop()
12837 
    oprot.writeStructEnd()
12838 
 
12839 
  def validate(self):
12840 
    return
12841 
 
12842 
 
12843 
  def __repr__(self):
12844 
    L = ['%s=%r' % (key, value)
12845 
      for key, value in self.__dict__.iteritems()]
12846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12847 
 
12848 
  def __eq__(self, other):
12849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12850 
 
12851 
  def __ne__(self, other):
12852 
    return not (self == other)
12853 
 
12854 
class getNonDeliveredOrdersbyCourier_result:
12855 
  """
12856 
  Attributes:
12857 
   - success
12858 
  """
12859 
 
12860 
  thrift_spec = (
12861 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12862 
  )
12863 
 
12864 
  def __init__(self, success=None,):
12865 
    self.success = success
12866 
 
12867 
  def read(self, iprot):
12868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12870 
      return
12871 
    iprot.readStructBegin()
12872 
    while True:
12873 
      (fname, ftype, fid) = iprot.readFieldBegin()
12874 
      if ftype == TType.STOP:
12875 
        break
4581 phani.kuma 12876 
      if fid == 0:
12877 
        if ftype == TType.LIST:
12878 
          self.success = []
5031 varun.gupt 12879 
          (_etype270, _size267) = iprot.readListBegin()
12880 
          for _i271 in xrange(_size267):
12881 
            _elem272 = Order()
12882 
            _elem272.read(iprot)
12883 
            self.success.append(_elem272)
4581 phani.kuma 12884 
          iprot.readListEnd()
12885 
        else:
12886 
          iprot.skip(ftype)
4910 phani.kuma 12887 
      else:
12888 
        iprot.skip(ftype)
12889 
      iprot.readFieldEnd()
12890 
    iprot.readStructEnd()
12891 
 
12892 
  def write(self, oprot):
12893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12895 
      return
12896 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
12897 
    if self.success is not None:
12898 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12899 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12900 
      for iter273 in self.success:
12901 
        iter273.write(oprot)
4910 phani.kuma 12902 
      oprot.writeListEnd()
12903 
      oprot.writeFieldEnd()
12904 
    oprot.writeFieldStop()
12905 
    oprot.writeStructEnd()
12906 
 
12907 
  def validate(self):
12908 
    return
12909 
 
12910 
 
12911 
  def __repr__(self):
12912 
    L = ['%s=%r' % (key, value)
12913 
      for key, value in self.__dict__.iteritems()]
12914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12915 
 
12916 
  def __eq__(self, other):
12917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12918 
 
12919 
  def __ne__(self, other):
12920 
    return not (self == other)
12921 
 
12922 
class markOrdersAsLocalConnected_args:
12923 
  """
12924 
  Attributes:
12925 
   - providerId
12926 
   - local_connected_orders
12927 
  """
12928 
 
12929 
  thrift_spec = (
12930 
    None, # 0
12931 
    (1, TType.I64, 'providerId', None, None, ), # 1
12932 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
12933 
  )
12934 
 
12935 
  def __init__(self, providerId=None, local_connected_orders=None,):
12936 
    self.providerId = providerId
12937 
    self.local_connected_orders = local_connected_orders
12938 
 
12939 
  def read(self, iprot):
12940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12942 
      return
12943 
    iprot.readStructBegin()
12944 
    while True:
12945 
      (fname, ftype, fid) = iprot.readFieldBegin()
12946 
      if ftype == TType.STOP:
12947 
        break
12948 
      if fid == 1:
12949 
        if ftype == TType.I64:
12950 
          self.providerId = iprot.readI64();
12951 
        else:
12952 
          iprot.skip(ftype)
12953 
      elif fid == 2:
12954 
        if ftype == TType.MAP:
12955 
          self.local_connected_orders = {}
5031 varun.gupt 12956 
          (_ktype275, _vtype276, _size274 ) = iprot.readMapBegin()
12957 
          for _i278 in xrange(_size274):
12958 
            _key279 = iprot.readString();
12959 
            _val280 = iprot.readString();
12960 
            self.local_connected_orders[_key279] = _val280
4910 phani.kuma 12961 
          iprot.readMapEnd()
12962 
        else:
12963 
          iprot.skip(ftype)
12964 
      else:
12965 
        iprot.skip(ftype)
12966 
      iprot.readFieldEnd()
12967 
    iprot.readStructEnd()
12968 
 
12969 
  def write(self, oprot):
12970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12972 
      return
12973 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
12974 
    if self.providerId is not None:
12975 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12976 
      oprot.writeI64(self.providerId)
12977 
      oprot.writeFieldEnd()
12978 
    if self.local_connected_orders is not None:
12979 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
12980 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
5031 varun.gupt 12981 
      for kiter281,viter282 in self.local_connected_orders.items():
12982 
        oprot.writeString(kiter281)
12983 
        oprot.writeString(viter282)
4910 phani.kuma 12984 
      oprot.writeMapEnd()
12985 
      oprot.writeFieldEnd()
12986 
    oprot.writeFieldStop()
12987 
    oprot.writeStructEnd()
12988 
 
12989 
  def validate(self):
12990 
    return
12991 
 
12992 
 
12993 
  def __repr__(self):
12994 
    L = ['%s=%r' % (key, value)
12995 
      for key, value in self.__dict__.iteritems()]
12996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12997 
 
12998 
  def __eq__(self, other):
12999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13000 
 
13001 
  def __ne__(self, other):
13002 
    return not (self == other)
13003 
 
13004 
class markOrdersAsLocalConnected_result:
13005 
  """
13006 
  Attributes:
13007 
   - ex
13008 
  """
13009 
 
13010 
  thrift_spec = (
13011 
    None, # 0
13012 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13013 
  )
13014 
 
13015 
  def __init__(self, ex=None,):
13016 
    self.ex = ex
13017 
 
13018 
  def read(self, iprot):
13019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13021 
      return
13022 
    iprot.readStructBegin()
13023 
    while True:
13024 
      (fname, ftype, fid) = iprot.readFieldBegin()
13025 
      if ftype == TType.STOP:
13026 
        break
13027 
      if fid == 1:
3064 chandransh 13028 
        if ftype == TType.STRUCT:
13029 
          self.ex = TransactionServiceException()
13030 
          self.ex.read(iprot)
1627 ankur.sing 13031 
        else:
13032 
          iprot.skip(ftype)
13033 
      else:
13034 
        iprot.skip(ftype)
13035 
      iprot.readFieldEnd()
13036 
    iprot.readStructEnd()
13037 
 
13038 
  def write(self, oprot):
13039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13041 
      return
4910 phani.kuma 13042 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
13043 
    if self.ex is not None:
13044 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13045 
      self.ex.write(oprot)
13046 
      oprot.writeFieldEnd()
13047 
    oprot.writeFieldStop()
13048 
    oprot.writeStructEnd()
13049 
 
13050 
  def validate(self):
13051 
    return
13052 
 
13053 
 
13054 
  def __repr__(self):
13055 
    L = ['%s=%r' % (key, value)
13056 
      for key, value in self.__dict__.iteritems()]
13057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13058 
 
13059 
  def __eq__(self, other):
13060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13061 
 
13062 
  def __ne__(self, other):
13063 
    return not (self == other)
13064 
 
13065 
class getOrdersNotLocalConnected_args:
13066 
  """
13067 
  Attributes:
13068 
   - providerId
13069 
  """
13070 
 
13071 
  thrift_spec = (
13072 
    None, # 0
13073 
    (1, TType.I64, 'providerId', None, None, ), # 1
13074 
  )
13075 
 
13076 
  def __init__(self, providerId=None,):
13077 
    self.providerId = providerId
13078 
 
13079 
  def read(self, iprot):
13080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13082 
      return
13083 
    iprot.readStructBegin()
13084 
    while True:
13085 
      (fname, ftype, fid) = iprot.readFieldBegin()
13086 
      if ftype == TType.STOP:
13087 
        break
13088 
      if fid == 1:
13089 
        if ftype == TType.I64:
13090 
          self.providerId = iprot.readI64();
13091 
        else:
13092 
          iprot.skip(ftype)
13093 
      else:
13094 
        iprot.skip(ftype)
13095 
      iprot.readFieldEnd()
13096 
    iprot.readStructEnd()
13097 
 
13098 
  def write(self, oprot):
13099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13101 
      return
13102 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
13103 
    if self.providerId is not None:
13104 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13105 
      oprot.writeI64(self.providerId)
13106 
      oprot.writeFieldEnd()
13107 
    oprot.writeFieldStop()
13108 
    oprot.writeStructEnd()
13109 
 
13110 
  def validate(self):
13111 
    return
13112 
 
13113 
 
13114 
  def __repr__(self):
13115 
    L = ['%s=%r' % (key, value)
13116 
      for key, value in self.__dict__.iteritems()]
13117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13118 
 
13119 
  def __eq__(self, other):
13120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13121 
 
13122 
  def __ne__(self, other):
13123 
    return not (self == other)
13124 
 
13125 
class getOrdersNotLocalConnected_result:
13126 
  """
13127 
  Attributes:
13128 
   - success
13129 
  """
13130 
 
13131 
  thrift_spec = (
13132 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13133 
  )
13134 
 
13135 
  def __init__(self, success=None,):
13136 
    self.success = success
13137 
 
13138 
  def read(self, iprot):
13139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13141 
      return
13142 
    iprot.readStructBegin()
13143 
    while True:
13144 
      (fname, ftype, fid) = iprot.readFieldBegin()
13145 
      if ftype == TType.STOP:
13146 
        break
13147 
      if fid == 0:
13148 
        if ftype == TType.LIST:
13149 
          self.success = []
5031 varun.gupt 13150 
          (_etype286, _size283) = iprot.readListBegin()
13151 
          for _i287 in xrange(_size283):
13152 
            _elem288 = Order()
13153 
            _elem288.read(iprot)
13154 
            self.success.append(_elem288)
4910 phani.kuma 13155 
          iprot.readListEnd()
13156 
        else:
13157 
          iprot.skip(ftype)
13158 
      else:
13159 
        iprot.skip(ftype)
13160 
      iprot.readFieldEnd()
13161 
    iprot.readStructEnd()
13162 
 
13163 
  def write(self, oprot):
13164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13166 
      return
13167 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 13168 
    if self.success is not None:
13169 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13170 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13171 
      for iter289 in self.success:
13172 
        iter289.write(oprot)
4581 phani.kuma 13173 
      oprot.writeListEnd()
13174 
      oprot.writeFieldEnd()
4910 phani.kuma 13175 
    oprot.writeFieldStop()
13176 
    oprot.writeStructEnd()
13177 
 
13178 
  def validate(self):
13179 
    return
13180 
 
13181 
 
13182 
  def __repr__(self):
13183 
    L = ['%s=%r' % (key, value)
13184 
      for key, value in self.__dict__.iteritems()]
13185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13186 
 
13187 
  def __eq__(self, other):
13188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13189 
 
13190 
  def __ne__(self, other):
13191 
    return not (self == other)
13192 
 
13193 
class markOrdersAsDestinationCityReached_args:
13194 
  """
13195 
  Attributes:
13196 
   - providerId
13197 
   - destination_city_reached_orders
13198 
  """
13199 
 
13200 
  thrift_spec = (
13201 
    None, # 0
13202 
    (1, TType.I64, 'providerId', None, None, ), # 1
13203 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13204 
  )
13205 
 
13206 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
13207 
    self.providerId = providerId
13208 
    self.destination_city_reached_orders = destination_city_reached_orders
13209 
 
13210 
  def read(self, iprot):
13211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13213 
      return
13214 
    iprot.readStructBegin()
13215 
    while True:
13216 
      (fname, ftype, fid) = iprot.readFieldBegin()
13217 
      if ftype == TType.STOP:
13218 
        break
13219 
      if fid == 1:
13220 
        if ftype == TType.I64:
13221 
          self.providerId = iprot.readI64();
13222 
        else:
13223 
          iprot.skip(ftype)
13224 
      elif fid == 2:
13225 
        if ftype == TType.MAP:
13226 
          self.destination_city_reached_orders = {}
5031 varun.gupt 13227 
          (_ktype291, _vtype292, _size290 ) = iprot.readMapBegin()
13228 
          for _i294 in xrange(_size290):
13229 
            _key295 = iprot.readString();
13230 
            _val296 = iprot.readString();
13231 
            self.destination_city_reached_orders[_key295] = _val296
4910 phani.kuma 13232 
          iprot.readMapEnd()
13233 
        else:
13234 
          iprot.skip(ftype)
13235 
      else:
13236 
        iprot.skip(ftype)
13237 
      iprot.readFieldEnd()
13238 
    iprot.readStructEnd()
13239 
 
13240 
  def write(self, oprot):
13241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13243 
      return
13244 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
13245 
    if self.providerId is not None:
13246 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13247 
      oprot.writeI64(self.providerId)
13248 
      oprot.writeFieldEnd()
13249 
    if self.destination_city_reached_orders is not None:
13250 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
13251 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
5031 varun.gupt 13252 
      for kiter297,viter298 in self.destination_city_reached_orders.items():
13253 
        oprot.writeString(kiter297)
13254 
        oprot.writeString(viter298)
4910 phani.kuma 13255 
      oprot.writeMapEnd()
13256 
      oprot.writeFieldEnd()
13257 
    oprot.writeFieldStop()
13258 
    oprot.writeStructEnd()
13259 
 
13260 
  def validate(self):
13261 
    return
13262 
 
13263 
 
13264 
  def __repr__(self):
13265 
    L = ['%s=%r' % (key, value)
13266 
      for key, value in self.__dict__.iteritems()]
13267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13268 
 
13269 
  def __eq__(self, other):
13270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13271 
 
13272 
  def __ne__(self, other):
13273 
    return not (self == other)
13274 
 
13275 
class markOrdersAsDestinationCityReached_result:
13276 
  """
13277 
  Attributes:
13278 
   - ex
13279 
  """
13280 
 
13281 
  thrift_spec = (
13282 
    None, # 0
13283 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13284 
  )
13285 
 
13286 
  def __init__(self, ex=None,):
13287 
    self.ex = ex
13288 
 
13289 
  def read(self, iprot):
13290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13292 
      return
13293 
    iprot.readStructBegin()
13294 
    while True:
13295 
      (fname, ftype, fid) = iprot.readFieldBegin()
13296 
      if ftype == TType.STOP:
13297 
        break
13298 
      if fid == 1:
13299 
        if ftype == TType.STRUCT:
13300 
          self.ex = TransactionServiceException()
13301 
          self.ex.read(iprot)
13302 
        else:
13303 
          iprot.skip(ftype)
13304 
      else:
13305 
        iprot.skip(ftype)
13306 
      iprot.readFieldEnd()
13307 
    iprot.readStructEnd()
13308 
 
13309 
  def write(self, oprot):
13310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13312 
      return
13313 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 13314 
    if self.ex is not None:
3064 chandransh 13315 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13316 
      self.ex.write(oprot)
1627 ankur.sing 13317 
      oprot.writeFieldEnd()
13318 
    oprot.writeFieldStop()
13319 
    oprot.writeStructEnd()
13320 
 
3431 rajveer 13321 
  def validate(self):
13322 
    return
13323 
 
13324 
 
1627 ankur.sing 13325 
  def __repr__(self):
13326 
    L = ['%s=%r' % (key, value)
13327 
      for key, value in self.__dict__.iteritems()]
13328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13329 
 
13330 
  def __eq__(self, other):
13331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13332 
 
13333 
  def __ne__(self, other):
13334 
    return not (self == other)
13335 
 
4910 phani.kuma 13336 
class markOrdersAsFirstDeliveryAttempted_args:
13337 
  """
13338 
  Attributes:
13339 
   - providerId
13340 
   - first_atdl_orders
13341 
  """
13342 
 
13343 
  thrift_spec = (
13344 
    None, # 0
13345 
    (1, TType.I64, 'providerId', None, None, ), # 1
13346 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13347 
  )
13348 
 
13349 
  def __init__(self, providerId=None, first_atdl_orders=None,):
13350 
    self.providerId = providerId
13351 
    self.first_atdl_orders = first_atdl_orders
13352 
 
13353 
  def read(self, iprot):
13354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13356 
      return
13357 
    iprot.readStructBegin()
13358 
    while True:
13359 
      (fname, ftype, fid) = iprot.readFieldBegin()
13360 
      if ftype == TType.STOP:
13361 
        break
13362 
      if fid == 1:
13363 
        if ftype == TType.I64:
13364 
          self.providerId = iprot.readI64();
13365 
        else:
13366 
          iprot.skip(ftype)
13367 
      elif fid == 2:
13368 
        if ftype == TType.MAP:
13369 
          self.first_atdl_orders = {}
5031 varun.gupt 13370 
          (_ktype300, _vtype301, _size299 ) = iprot.readMapBegin()
13371 
          for _i303 in xrange(_size299):
13372 
            _key304 = iprot.readString();
13373 
            _val305 = iprot.readString();
13374 
            self.first_atdl_orders[_key304] = _val305
4910 phani.kuma 13375 
          iprot.readMapEnd()
13376 
        else:
13377 
          iprot.skip(ftype)
13378 
      else:
13379 
        iprot.skip(ftype)
13380 
      iprot.readFieldEnd()
13381 
    iprot.readStructEnd()
13382 
 
13383 
  def write(self, oprot):
13384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13386 
      return
13387 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
13388 
    if self.providerId is not None:
13389 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13390 
      oprot.writeI64(self.providerId)
13391 
      oprot.writeFieldEnd()
13392 
    if self.first_atdl_orders is not None:
13393 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
13394 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
5031 varun.gupt 13395 
      for kiter306,viter307 in self.first_atdl_orders.items():
13396 
        oprot.writeString(kiter306)
13397 
        oprot.writeString(viter307)
4910 phani.kuma 13398 
      oprot.writeMapEnd()
13399 
      oprot.writeFieldEnd()
13400 
    oprot.writeFieldStop()
13401 
    oprot.writeStructEnd()
13402 
 
13403 
  def validate(self):
13404 
    return
13405 
 
13406 
 
13407 
  def __repr__(self):
13408 
    L = ['%s=%r' % (key, value)
13409 
      for key, value in self.__dict__.iteritems()]
13410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13411 
 
13412 
  def __eq__(self, other):
13413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13414 
 
13415 
  def __ne__(self, other):
13416 
    return not (self == other)
13417 
 
13418 
class markOrdersAsFirstDeliveryAttempted_result:
13419 
  """
13420 
  Attributes:
13421 
   - ex
13422 
  """
13423 
 
13424 
  thrift_spec = (
13425 
    None, # 0
13426 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13427 
  )
13428 
 
13429 
  def __init__(self, ex=None,):
13430 
    self.ex = ex
13431 
 
13432 
  def read(self, iprot):
13433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13435 
      return
13436 
    iprot.readStructBegin()
13437 
    while True:
13438 
      (fname, ftype, fid) = iprot.readFieldBegin()
13439 
      if ftype == TType.STOP:
13440 
        break
13441 
      if fid == 1:
13442 
        if ftype == TType.STRUCT:
13443 
          self.ex = TransactionServiceException()
13444 
          self.ex.read(iprot)
13445 
        else:
13446 
          iprot.skip(ftype)
13447 
      else:
13448 
        iprot.skip(ftype)
13449 
      iprot.readFieldEnd()
13450 
    iprot.readStructEnd()
13451 
 
13452 
  def write(self, oprot):
13453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13455 
      return
13456 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
13457 
    if self.ex is not None:
13458 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13459 
      self.ex.write(oprot)
13460 
      oprot.writeFieldEnd()
13461 
    oprot.writeFieldStop()
13462 
    oprot.writeStructEnd()
13463 
 
13464 
  def validate(self):
13465 
    return
13466 
 
13467 
 
13468 
  def __repr__(self):
13469 
    L = ['%s=%r' % (key, value)
13470 
      for key, value in self.__dict__.iteritems()]
13471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13472 
 
13473 
  def __eq__(self, other):
13474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13475 
 
13476 
  def __ne__(self, other):
13477 
    return not (self == other)
13478 
 
3064 chandransh 13479 
class getUndeliveredOrders_args:
1886 ankur.sing 13480 
  """
13481 
  Attributes:
3064 chandransh 13482 
   - providerId
13483 
   - warehouseId
1886 ankur.sing 13484 
  """
1627 ankur.sing 13485 
 
1886 ankur.sing 13486 
  thrift_spec = (
13487 
    None, # 0
3064 chandransh 13488 
    (1, TType.I64, 'providerId', None, None, ), # 1
13489 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 13490 
  )
13491 
 
3064 chandransh 13492 
  def __init__(self, providerId=None, warehouseId=None,):
13493 
    self.providerId = providerId
13494 
    self.warehouseId = warehouseId
1886 ankur.sing 13495 
 
13496 
  def read(self, iprot):
13497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13499 
      return
13500 
    iprot.readStructBegin()
13501 
    while True:
13502 
      (fname, ftype, fid) = iprot.readFieldBegin()
13503 
      if ftype == TType.STOP:
13504 
        break
13505 
      if fid == 1:
13506 
        if ftype == TType.I64:
3064 chandransh 13507 
          self.providerId = iprot.readI64();
1886 ankur.sing 13508 
        else:
13509 
          iprot.skip(ftype)
3064 chandransh 13510 
      elif fid == 2:
13511 
        if ftype == TType.I64:
13512 
          self.warehouseId = iprot.readI64();
13513 
        else:
13514 
          iprot.skip(ftype)
1886 ankur.sing 13515 
      else:
13516 
        iprot.skip(ftype)
13517 
      iprot.readFieldEnd()
13518 
    iprot.readStructEnd()
13519 
 
13520 
  def write(self, oprot):
13521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13523 
      return
3064 chandransh 13524 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 13525 
    if self.providerId is not None:
3064 chandransh 13526 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13527 
      oprot.writeI64(self.providerId)
1886 ankur.sing 13528 
      oprot.writeFieldEnd()
3431 rajveer 13529 
    if self.warehouseId is not None:
3064 chandransh 13530 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13531 
      oprot.writeI64(self.warehouseId)
13532 
      oprot.writeFieldEnd()
1886 ankur.sing 13533 
    oprot.writeFieldStop()
13534 
    oprot.writeStructEnd()
13535 
 
3431 rajveer 13536 
  def validate(self):
13537 
    return
13538 
 
13539 
 
1886 ankur.sing 13540 
  def __repr__(self):
13541 
    L = ['%s=%r' % (key, value)
13542 
      for key, value in self.__dict__.iteritems()]
13543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13544 
 
13545 
  def __eq__(self, other):
13546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13547 
 
13548 
  def __ne__(self, other):
13549 
    return not (self == other)
13550 
 
3064 chandransh 13551 
class getUndeliveredOrders_result:
1886 ankur.sing 13552 
  """
13553 
  Attributes:
13554 
   - success
13555 
  """
13556 
 
13557 
  thrift_spec = (
13558 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13559 
  )
13560 
 
13561 
  def __init__(self, success=None,):
13562 
    self.success = success
13563 
 
13564 
  def read(self, iprot):
13565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13567 
      return
13568 
    iprot.readStructBegin()
13569 
    while True:
13570 
      (fname, ftype, fid) = iprot.readFieldBegin()
13571 
      if ftype == TType.STOP:
13572 
        break
13573 
      if fid == 0:
13574 
        if ftype == TType.LIST:
13575 
          self.success = []
5031 varun.gupt 13576 
          (_etype311, _size308) = iprot.readListBegin()
13577 
          for _i312 in xrange(_size308):
13578 
            _elem313 = Order()
13579 
            _elem313.read(iprot)
13580 
            self.success.append(_elem313)
1886 ankur.sing 13581 
          iprot.readListEnd()
13582 
        else:
13583 
          iprot.skip(ftype)
13584 
      else:
13585 
        iprot.skip(ftype)
13586 
      iprot.readFieldEnd()
13587 
    iprot.readStructEnd()
13588 
 
13589 
  def write(self, oprot):
13590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13592 
      return
3064 chandransh 13593 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 13594 
    if self.success is not None:
1886 ankur.sing 13595 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13596 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13597 
      for iter314 in self.success:
13598 
        iter314.write(oprot)
1886 ankur.sing 13599 
      oprot.writeListEnd()
13600 
      oprot.writeFieldEnd()
13601 
    oprot.writeFieldStop()
13602 
    oprot.writeStructEnd()
13603 
 
3431 rajveer 13604 
  def validate(self):
13605 
    return
13606 
 
13607 
 
1886 ankur.sing 13608 
  def __repr__(self):
13609 
    L = ['%s=%r' % (key, value)
13610 
      for key, value in self.__dict__.iteritems()]
13611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13612 
 
13613 
  def __eq__(self, other):
13614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13615 
 
13616 
  def __ne__(self, other):
13617 
    return not (self == other)
13618 
 
4783 phani.kuma 13619 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
13620 
 
13621 
  thrift_spec = (
13622 
  )
13623 
 
13624 
  def read(self, iprot):
13625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13627 
      return
13628 
    iprot.readStructBegin()
13629 
    while True:
13630 
      (fname, ftype, fid) = iprot.readFieldBegin()
13631 
      if ftype == TType.STOP:
13632 
        break
13633 
      else:
13634 
        iprot.skip(ftype)
13635 
      iprot.readFieldEnd()
13636 
    iprot.readStructEnd()
13637 
 
13638 
  def write(self, oprot):
13639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13641 
      return
13642 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
13643 
    oprot.writeFieldStop()
13644 
    oprot.writeStructEnd()
13645 
 
13646 
  def validate(self):
13647 
    return
13648 
 
13649 
 
13650 
  def __repr__(self):
13651 
    L = ['%s=%r' % (key, value)
13652 
      for key, value in self.__dict__.iteritems()]
13653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13654 
 
13655 
  def __eq__(self, other):
13656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13657 
 
13658 
  def __ne__(self, other):
13659 
    return not (self == other)
13660 
 
13661 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
13662 
  """
13663 
  Attributes:
13664 
   - success
13665 
  """
13666 
 
13667 
  thrift_spec = (
13668 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13669 
  )
13670 
 
13671 
  def __init__(self, success=None,):
13672 
    self.success = success
13673 
 
13674 
  def read(self, iprot):
13675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13677 
      return
13678 
    iprot.readStructBegin()
13679 
    while True:
13680 
      (fname, ftype, fid) = iprot.readFieldBegin()
13681 
      if ftype == TType.STOP:
13682 
        break
13683 
      if fid == 0:
13684 
        if ftype == TType.LIST:
13685 
          self.success = []
5031 varun.gupt 13686 
          (_etype318, _size315) = iprot.readListBegin()
13687 
          for _i319 in xrange(_size315):
13688 
            _elem320 = Order()
13689 
            _elem320.read(iprot)
13690 
            self.success.append(_elem320)
4783 phani.kuma 13691 
          iprot.readListEnd()
13692 
        else:
13693 
          iprot.skip(ftype)
13694 
      else:
13695 
        iprot.skip(ftype)
13696 
      iprot.readFieldEnd()
13697 
    iprot.readStructEnd()
13698 
 
13699 
  def write(self, oprot):
13700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13702 
      return
13703 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
13704 
    if self.success is not None:
13705 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13706 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13707 
      for iter321 in self.success:
13708 
        iter321.write(oprot)
4783 phani.kuma 13709 
      oprot.writeListEnd()
13710 
      oprot.writeFieldEnd()
13711 
    oprot.writeFieldStop()
13712 
    oprot.writeStructEnd()
13713 
 
13714 
  def validate(self):
13715 
    return
13716 
 
13717 
 
13718 
  def __repr__(self):
13719 
    L = ['%s=%r' % (key, value)
13720 
      for key, value in self.__dict__.iteritems()]
13721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13722 
 
13723 
  def __eq__(self, other):
13724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13725 
 
13726 
  def __ne__(self, other):
13727 
    return not (self == other)
13728 
 
2536 chandransh 13729 
class toggleDOAFlag_args:
13730 
  """
13731 
  Attributes:
13732 
   - orderId
13733 
  """
1886 ankur.sing 13734 
 
2536 chandransh 13735 
  thrift_spec = (
13736 
    None, # 0
13737 
    (1, TType.I64, 'orderId', None, None, ), # 1
13738 
  )
13739 
 
13740 
  def __init__(self, orderId=None,):
13741 
    self.orderId = orderId
13742 
 
13743 
  def read(self, iprot):
13744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13746 
      return
13747 
    iprot.readStructBegin()
13748 
    while True:
13749 
      (fname, ftype, fid) = iprot.readFieldBegin()
13750 
      if ftype == TType.STOP:
13751 
        break
13752 
      if fid == 1:
13753 
        if ftype == TType.I64:
13754 
          self.orderId = iprot.readI64();
13755 
        else:
13756 
          iprot.skip(ftype)
13757 
      else:
13758 
        iprot.skip(ftype)
13759 
      iprot.readFieldEnd()
13760 
    iprot.readStructEnd()
13761 
 
13762 
  def write(self, oprot):
13763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13765 
      return
13766 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 13767 
    if self.orderId is not None:
2536 chandransh 13768 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13769 
      oprot.writeI64(self.orderId)
13770 
      oprot.writeFieldEnd()
13771 
    oprot.writeFieldStop()
13772 
    oprot.writeStructEnd()
13773 
 
3431 rajveer 13774 
  def validate(self):
13775 
    return
13776 
 
13777 
 
2536 chandransh 13778 
  def __repr__(self):
13779 
    L = ['%s=%r' % (key, value)
13780 
      for key, value in self.__dict__.iteritems()]
13781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13782 
 
13783 
  def __eq__(self, other):
13784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13785 
 
13786 
  def __ne__(self, other):
13787 
    return not (self == other)
13788 
 
13789 
class toggleDOAFlag_result:
13790 
  """
13791 
  Attributes:
13792 
   - success
13793 
   - ex
13794 
  """
13795 
 
13796 
  thrift_spec = (
13797 
    (0, TType.BOOL, 'success', None, None, ), # 0
13798 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13799 
  )
13800 
 
13801 
  def __init__(self, success=None, ex=None,):
13802 
    self.success = success
13803 
    self.ex = ex
13804 
 
13805 
  def read(self, iprot):
13806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13808 
      return
13809 
    iprot.readStructBegin()
13810 
    while True:
13811 
      (fname, ftype, fid) = iprot.readFieldBegin()
13812 
      if ftype == TType.STOP:
13813 
        break
13814 
      if fid == 0:
13815 
        if ftype == TType.BOOL:
13816 
          self.success = iprot.readBool();
13817 
        else:
13818 
          iprot.skip(ftype)
13819 
      elif fid == 1:
13820 
        if ftype == TType.STRUCT:
13821 
          self.ex = TransactionServiceException()
13822 
          self.ex.read(iprot)
13823 
        else:
13824 
          iprot.skip(ftype)
13825 
      else:
13826 
        iprot.skip(ftype)
13827 
      iprot.readFieldEnd()
13828 
    iprot.readStructEnd()
13829 
 
13830 
  def write(self, oprot):
13831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13833 
      return
13834 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 13835 
    if self.success is not None:
2536 chandransh 13836 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13837 
      oprot.writeBool(self.success)
13838 
      oprot.writeFieldEnd()
3431 rajveer 13839 
    if self.ex is not None:
2536 chandransh 13840 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13841 
      self.ex.write(oprot)
13842 
      oprot.writeFieldEnd()
13843 
    oprot.writeFieldStop()
13844 
    oprot.writeStructEnd()
13845 
 
3431 rajveer 13846 
  def validate(self):
13847 
    return
13848 
 
13849 
 
2536 chandransh 13850 
  def __repr__(self):
13851 
    L = ['%s=%r' % (key, value)
13852 
      for key, value in self.__dict__.iteritems()]
13853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13854 
 
13855 
  def __eq__(self, other):
13856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13857 
 
13858 
  def __ne__(self, other):
13859 
    return not (self == other)
13860 
 
4712 rajveer 13861 
class markOrderAsDelivered_args:
13862 
  """
13863 
  Attributes:
13864 
   - orderId
13865 
   - deliveryTimestamp
13866 
   - receiver
13867 
  """
13868 
 
13869 
  thrift_spec = None
13870 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
13871 
    self.orderId = orderId
13872 
    self.deliveryTimestamp = deliveryTimestamp
13873 
    self.receiver = receiver
13874 
 
13875 
  def read(self, iprot):
13876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13878 
      return
13879 
    iprot.readStructBegin()
13880 
    while True:
13881 
      (fname, ftype, fid) = iprot.readFieldBegin()
13882 
      if ftype == TType.STOP:
13883 
        break
13884 
      if fid == 1:
13885 
        if ftype == TType.I64:
13886 
          self.orderId = iprot.readI64();
13887 
        else:
13888 
          iprot.skip(ftype)
13889 
      elif fid == 2:
13890 
        if ftype == TType.I64:
13891 
          self.deliveryTimestamp = iprot.readI64();
13892 
        else:
13893 
          iprot.skip(ftype)
13894 
      elif fid == -1:
13895 
        if ftype == TType.STRING:
13896 
          self.receiver = iprot.readString();
13897 
        else:
13898 
          iprot.skip(ftype)
13899 
      else:
13900 
        iprot.skip(ftype)
13901 
      iprot.readFieldEnd()
13902 
    iprot.readStructEnd()
13903 
 
13904 
  def write(self, oprot):
13905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13907 
      return
13908 
    oprot.writeStructBegin('markOrderAsDelivered_args')
13909 
    if self.receiver is not None:
13910 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
13911 
      oprot.writeString(self.receiver)
13912 
      oprot.writeFieldEnd()
13913 
    if self.orderId is not None:
13914 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13915 
      oprot.writeI64(self.orderId)
13916 
      oprot.writeFieldEnd()
13917 
    if self.deliveryTimestamp is not None:
13918 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
13919 
      oprot.writeI64(self.deliveryTimestamp)
13920 
      oprot.writeFieldEnd()
13921 
    oprot.writeFieldStop()
13922 
    oprot.writeStructEnd()
13923 
 
13924 
  def validate(self):
13925 
    return
13926 
 
13927 
 
13928 
  def __repr__(self):
13929 
    L = ['%s=%r' % (key, value)
13930 
      for key, value in self.__dict__.iteritems()]
13931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13932 
 
13933 
  def __eq__(self, other):
13934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13935 
 
13936 
  def __ne__(self, other):
13937 
    return not (self == other)
13938 
 
13939 
class markOrderAsDelivered_result:
13940 
  """
13941 
  Attributes:
13942 
   - ex
13943 
  """
13944 
 
13945 
  thrift_spec = (
13946 
    None, # 0
13947 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13948 
  )
13949 
 
13950 
  def __init__(self, ex=None,):
13951 
    self.ex = ex
13952 
 
13953 
  def read(self, iprot):
13954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13956 
      return
13957 
    iprot.readStructBegin()
13958 
    while True:
13959 
      (fname, ftype, fid) = iprot.readFieldBegin()
13960 
      if ftype == TType.STOP:
13961 
        break
13962 
      if fid == 1:
13963 
        if ftype == TType.STRUCT:
13964 
          self.ex = TransactionServiceException()
13965 
          self.ex.read(iprot)
13966 
        else:
13967 
          iprot.skip(ftype)
13968 
      else:
13969 
        iprot.skip(ftype)
13970 
      iprot.readFieldEnd()
13971 
    iprot.readStructEnd()
13972 
 
13973 
  def write(self, oprot):
13974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13976 
      return
13977 
    oprot.writeStructBegin('markOrderAsDelivered_result')
13978 
    if self.ex is not None:
13979 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13980 
      self.ex.write(oprot)
13981 
      oprot.writeFieldEnd()
13982 
    oprot.writeFieldStop()
13983 
    oprot.writeStructEnd()
13984 
 
13985 
  def validate(self):
13986 
    return
13987 
 
13988 
 
13989 
  def __repr__(self):
13990 
    L = ['%s=%r' % (key, value)
13991 
      for key, value in self.__dict__.iteritems()]
13992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13993 
 
13994 
  def __eq__(self, other):
13995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13996 
 
13997 
  def __ne__(self, other):
13998 
    return not (self == other)
13999 
 
4454 rajveer 14000 
class markOrderDoaRequestReceived_args:
14001 
  """
14002 
  Attributes:
14003 
   - orderId
14004 
  """
14005 
 
14006 
  thrift_spec = (
14007 
    None, # 0
14008 
    (1, TType.I64, 'orderId', None, None, ), # 1
14009 
  )
14010 
 
14011 
  def __init__(self, orderId=None,):
14012 
    self.orderId = orderId
14013 
 
14014 
  def read(self, iprot):
14015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14017 
      return
14018 
    iprot.readStructBegin()
14019 
    while True:
14020 
      (fname, ftype, fid) = iprot.readFieldBegin()
14021 
      if ftype == TType.STOP:
14022 
        break
14023 
      if fid == 1:
14024 
        if ftype == TType.I64:
14025 
          self.orderId = iprot.readI64();
14026 
        else:
14027 
          iprot.skip(ftype)
14028 
      else:
14029 
        iprot.skip(ftype)
14030 
      iprot.readFieldEnd()
14031 
    iprot.readStructEnd()
14032 
 
14033 
  def write(self, oprot):
14034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14036 
      return
14037 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
14038 
    if self.orderId is not None:
14039 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14040 
      oprot.writeI64(self.orderId)
14041 
      oprot.writeFieldEnd()
14042 
    oprot.writeFieldStop()
14043 
    oprot.writeStructEnd()
14044 
 
14045 
  def validate(self):
14046 
    return
14047 
 
14048 
 
14049 
  def __repr__(self):
14050 
    L = ['%s=%r' % (key, value)
14051 
      for key, value in self.__dict__.iteritems()]
14052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14053 
 
14054 
  def __eq__(self, other):
14055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14056 
 
14057 
  def __ne__(self, other):
14058 
    return not (self == other)
14059 
 
14060 
class markOrderDoaRequestReceived_result:
14061 
  """
14062 
  Attributes:
14063 
   - success
14064 
   - ex
14065 
  """
14066 
 
14067 
  thrift_spec = (
14068 
    (0, TType.BOOL, 'success', None, None, ), # 0
14069 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14070 
  )
14071 
 
14072 
  def __init__(self, success=None, ex=None,):
14073 
    self.success = success
14074 
    self.ex = ex
14075 
 
14076 
  def read(self, iprot):
14077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14079 
      return
14080 
    iprot.readStructBegin()
14081 
    while True:
14082 
      (fname, ftype, fid) = iprot.readFieldBegin()
14083 
      if ftype == TType.STOP:
14084 
        break
14085 
      if fid == 0:
14086 
        if ftype == TType.BOOL:
14087 
          self.success = iprot.readBool();
14088 
        else:
14089 
          iprot.skip(ftype)
14090 
      elif fid == 1:
14091 
        if ftype == TType.STRUCT:
14092 
          self.ex = TransactionServiceException()
14093 
          self.ex.read(iprot)
14094 
        else:
14095 
          iprot.skip(ftype)
14096 
      else:
14097 
        iprot.skip(ftype)
14098 
      iprot.readFieldEnd()
14099 
    iprot.readStructEnd()
14100 
 
14101 
  def write(self, oprot):
14102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14104 
      return
14105 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
14106 
    if self.success is not None:
14107 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14108 
      oprot.writeBool(self.success)
14109 
      oprot.writeFieldEnd()
14110 
    if self.ex is not None:
14111 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14112 
      self.ex.write(oprot)
14113 
      oprot.writeFieldEnd()
14114 
    oprot.writeFieldStop()
14115 
    oprot.writeStructEnd()
14116 
 
14117 
  def validate(self):
14118 
    return
14119 
 
14120 
 
14121 
  def __repr__(self):
14122 
    L = ['%s=%r' % (key, value)
14123 
      for key, value in self.__dict__.iteritems()]
14124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14125 
 
14126 
  def __eq__(self, other):
14127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14128 
 
14129 
  def __ne__(self, other):
14130 
    return not (self == other)
14131 
 
14132 
class markOrderDoaRequestAuthorized_args:
14133 
  """
14134 
  Attributes:
14135 
   - orderId
14136 
   - isAuthorized
14137 
  """
14138 
 
14139 
  thrift_spec = (
14140 
    None, # 0
14141 
    (1, TType.I64, 'orderId', None, None, ), # 1
14142 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14143 
  )
14144 
 
14145 
  def __init__(self, orderId=None, isAuthorized=None,):
14146 
    self.orderId = orderId
14147 
    self.isAuthorized = isAuthorized
14148 
 
14149 
  def read(self, iprot):
14150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14152 
      return
14153 
    iprot.readStructBegin()
14154 
    while True:
14155 
      (fname, ftype, fid) = iprot.readFieldBegin()
14156 
      if ftype == TType.STOP:
14157 
        break
14158 
      if fid == 1:
14159 
        if ftype == TType.I64:
14160 
          self.orderId = iprot.readI64();
14161 
        else:
14162 
          iprot.skip(ftype)
14163 
      elif fid == 2:
14164 
        if ftype == TType.BOOL:
14165 
          self.isAuthorized = iprot.readBool();
14166 
        else:
14167 
          iprot.skip(ftype)
14168 
      else:
14169 
        iprot.skip(ftype)
14170 
      iprot.readFieldEnd()
14171 
    iprot.readStructEnd()
14172 
 
14173 
  def write(self, oprot):
14174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14176 
      return
14177 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
14178 
    if self.orderId is not None:
14179 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14180 
      oprot.writeI64(self.orderId)
14181 
      oprot.writeFieldEnd()
14182 
    if self.isAuthorized is not None:
14183 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14184 
      oprot.writeBool(self.isAuthorized)
14185 
      oprot.writeFieldEnd()
14186 
    oprot.writeFieldStop()
14187 
    oprot.writeStructEnd()
14188 
 
14189 
  def validate(self):
14190 
    return
14191 
 
14192 
 
14193 
  def __repr__(self):
14194 
    L = ['%s=%r' % (key, value)
14195 
      for key, value in self.__dict__.iteritems()]
14196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14197 
 
14198 
  def __eq__(self, other):
14199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14200 
 
14201 
  def __ne__(self, other):
14202 
    return not (self == other)
14203 
 
14204 
class markOrderDoaRequestAuthorized_result:
14205 
  """
14206 
  Attributes:
14207 
   - success
14208 
   - ex
14209 
  """
14210 
 
14211 
  thrift_spec = (
14212 
    (0, TType.BOOL, 'success', None, None, ), # 0
14213 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14214 
  )
14215 
 
14216 
  def __init__(self, success=None, ex=None,):
14217 
    self.success = success
14218 
    self.ex = ex
14219 
 
14220 
  def read(self, iprot):
14221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14223 
      return
14224 
    iprot.readStructBegin()
14225 
    while True:
14226 
      (fname, ftype, fid) = iprot.readFieldBegin()
14227 
      if ftype == TType.STOP:
14228 
        break
14229 
      if fid == 0:
14230 
        if ftype == TType.BOOL:
14231 
          self.success = iprot.readBool();
14232 
        else:
14233 
          iprot.skip(ftype)
14234 
      elif fid == 1:
14235 
        if ftype == TType.STRUCT:
14236 
          self.ex = TransactionServiceException()
14237 
          self.ex.read(iprot)
14238 
        else:
14239 
          iprot.skip(ftype)
14240 
      else:
14241 
        iprot.skip(ftype)
14242 
      iprot.readFieldEnd()
14243 
    iprot.readStructEnd()
14244 
 
14245 
  def write(self, oprot):
14246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14248 
      return
14249 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
14250 
    if self.success is not None:
14251 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14252 
      oprot.writeBool(self.success)
14253 
      oprot.writeFieldEnd()
14254 
    if self.ex is not None:
14255 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14256 
      self.ex.write(oprot)
14257 
      oprot.writeFieldEnd()
14258 
    oprot.writeFieldStop()
14259 
    oprot.writeStructEnd()
14260 
 
14261 
  def validate(self):
14262 
    return
14263 
 
14264 
 
14265 
  def __repr__(self):
14266 
    L = ['%s=%r' % (key, value)
14267 
      for key, value in self.__dict__.iteritems()]
14268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14269 
 
14270 
  def __eq__(self, other):
14271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14272 
 
14273 
  def __ne__(self, other):
14274 
    return not (self == other)
14275 
 
4488 rajveer 14276 
class markOrderReturnRequestReceived_args:
14277 
  """
14278 
  Attributes:
14279 
   - orderId
14280 
  """
14281 
 
14282 
  thrift_spec = (
14283 
    None, # 0
14284 
    (1, TType.I64, 'orderId', None, None, ), # 1
14285 
  )
14286 
 
14287 
  def __init__(self, orderId=None,):
14288 
    self.orderId = orderId
14289 
 
14290 
  def read(self, iprot):
14291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14293 
      return
14294 
    iprot.readStructBegin()
14295 
    while True:
14296 
      (fname, ftype, fid) = iprot.readFieldBegin()
14297 
      if ftype == TType.STOP:
14298 
        break
14299 
      if fid == 1:
14300 
        if ftype == TType.I64:
14301 
          self.orderId = iprot.readI64();
14302 
        else:
14303 
          iprot.skip(ftype)
14304 
      else:
14305 
        iprot.skip(ftype)
14306 
      iprot.readFieldEnd()
14307 
    iprot.readStructEnd()
14308 
 
14309 
  def write(self, oprot):
14310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14312 
      return
14313 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
14314 
    if self.orderId is not None:
14315 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14316 
      oprot.writeI64(self.orderId)
14317 
      oprot.writeFieldEnd()
14318 
    oprot.writeFieldStop()
14319 
    oprot.writeStructEnd()
14320 
 
14321 
  def validate(self):
14322 
    return
14323 
 
14324 
 
14325 
  def __repr__(self):
14326 
    L = ['%s=%r' % (key, value)
14327 
      for key, value in self.__dict__.iteritems()]
14328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14329 
 
14330 
  def __eq__(self, other):
14331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14332 
 
14333 
  def __ne__(self, other):
14334 
    return not (self == other)
14335 
 
14336 
class markOrderReturnRequestReceived_result:
14337 
  """
14338 
  Attributes:
14339 
   - success
14340 
   - ex
14341 
  """
14342 
 
14343 
  thrift_spec = (
14344 
    (0, TType.BOOL, 'success', None, None, ), # 0
14345 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14346 
  )
14347 
 
14348 
  def __init__(self, success=None, ex=None,):
14349 
    self.success = success
14350 
    self.ex = ex
14351 
 
14352 
  def read(self, iprot):
14353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14355 
      return
14356 
    iprot.readStructBegin()
14357 
    while True:
14358 
      (fname, ftype, fid) = iprot.readFieldBegin()
14359 
      if ftype == TType.STOP:
14360 
        break
14361 
      if fid == 0:
14362 
        if ftype == TType.BOOL:
14363 
          self.success = iprot.readBool();
14364 
        else:
14365 
          iprot.skip(ftype)
14366 
      elif fid == 1:
14367 
        if ftype == TType.STRUCT:
14368 
          self.ex = TransactionServiceException()
14369 
          self.ex.read(iprot)
14370 
        else:
14371 
          iprot.skip(ftype)
14372 
      else:
14373 
        iprot.skip(ftype)
14374 
      iprot.readFieldEnd()
14375 
    iprot.readStructEnd()
14376 
 
14377 
  def write(self, oprot):
14378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14380 
      return
14381 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
14382 
    if self.success is not None:
14383 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14384 
      oprot.writeBool(self.success)
14385 
      oprot.writeFieldEnd()
14386 
    if self.ex is not None:
14387 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14388 
      self.ex.write(oprot)
14389 
      oprot.writeFieldEnd()
14390 
    oprot.writeFieldStop()
14391 
    oprot.writeStructEnd()
14392 
 
14393 
  def validate(self):
14394 
    return
14395 
 
14396 
 
14397 
  def __repr__(self):
14398 
    L = ['%s=%r' % (key, value)
14399 
      for key, value in self.__dict__.iteritems()]
14400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14401 
 
14402 
  def __eq__(self, other):
14403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14404 
 
14405 
  def __ne__(self, other):
14406 
    return not (self == other)
14407 
 
14408 
class markOrderReturnRequestAuthorized_args:
14409 
  """
14410 
  Attributes:
14411 
   - orderId
14412 
   - isAuthorized
14413 
  """
14414 
 
14415 
  thrift_spec = (
14416 
    None, # 0
14417 
    (1, TType.I64, 'orderId', None, None, ), # 1
14418 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14419 
  )
14420 
 
14421 
  def __init__(self, orderId=None, isAuthorized=None,):
14422 
    self.orderId = orderId
14423 
    self.isAuthorized = isAuthorized
14424 
 
14425 
  def read(self, iprot):
14426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14428 
      return
14429 
    iprot.readStructBegin()
14430 
    while True:
14431 
      (fname, ftype, fid) = iprot.readFieldBegin()
14432 
      if ftype == TType.STOP:
14433 
        break
14434 
      if fid == 1:
14435 
        if ftype == TType.I64:
14436 
          self.orderId = iprot.readI64();
14437 
        else:
14438 
          iprot.skip(ftype)
14439 
      elif fid == 2:
14440 
        if ftype == TType.BOOL:
14441 
          self.isAuthorized = iprot.readBool();
14442 
        else:
14443 
          iprot.skip(ftype)
14444 
      else:
14445 
        iprot.skip(ftype)
14446 
      iprot.readFieldEnd()
14447 
    iprot.readStructEnd()
14448 
 
14449 
  def write(self, oprot):
14450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14452 
      return
14453 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
14454 
    if self.orderId is not None:
14455 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14456 
      oprot.writeI64(self.orderId)
14457 
      oprot.writeFieldEnd()
14458 
    if self.isAuthorized is not None:
14459 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14460 
      oprot.writeBool(self.isAuthorized)
14461 
      oprot.writeFieldEnd()
14462 
    oprot.writeFieldStop()
14463 
    oprot.writeStructEnd()
14464 
 
14465 
  def validate(self):
14466 
    return
14467 
 
14468 
 
14469 
  def __repr__(self):
14470 
    L = ['%s=%r' % (key, value)
14471 
      for key, value in self.__dict__.iteritems()]
14472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14473 
 
14474 
  def __eq__(self, other):
14475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14476 
 
14477 
  def __ne__(self, other):
14478 
    return not (self == other)
14479 
 
14480 
class markOrderReturnRequestAuthorized_result:
14481 
  """
14482 
  Attributes:
14483 
   - success
14484 
   - ex
14485 
  """
14486 
 
14487 
  thrift_spec = (
14488 
    (0, TType.BOOL, 'success', None, None, ), # 0
14489 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14490 
  )
14491 
 
14492 
  def __init__(self, success=None, ex=None,):
14493 
    self.success = success
14494 
    self.ex = ex
14495 
 
14496 
  def read(self, iprot):
14497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14499 
      return
14500 
    iprot.readStructBegin()
14501 
    while True:
14502 
      (fname, ftype, fid) = iprot.readFieldBegin()
14503 
      if ftype == TType.STOP:
14504 
        break
14505 
      if fid == 0:
14506 
        if ftype == TType.BOOL:
14507 
          self.success = iprot.readBool();
14508 
        else:
14509 
          iprot.skip(ftype)
14510 
      elif fid == 1:
14511 
        if ftype == TType.STRUCT:
14512 
          self.ex = TransactionServiceException()
14513 
          self.ex.read(iprot)
14514 
        else:
14515 
          iprot.skip(ftype)
14516 
      else:
14517 
        iprot.skip(ftype)
14518 
      iprot.readFieldEnd()
14519 
    iprot.readStructEnd()
14520 
 
14521 
  def write(self, oprot):
14522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14524 
      return
14525 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
14526 
    if self.success is not None:
14527 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14528 
      oprot.writeBool(self.success)
14529 
      oprot.writeFieldEnd()
14530 
    if self.ex is not None:
14531 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14532 
      self.ex.write(oprot)
14533 
      oprot.writeFieldEnd()
14534 
    oprot.writeFieldStop()
14535 
    oprot.writeStructEnd()
14536 
 
14537 
  def validate(self):
14538 
    return
14539 
 
14540 
 
14541 
  def __repr__(self):
14542 
    L = ['%s=%r' % (key, value)
14543 
      for key, value in self.__dict__.iteritems()]
14544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14545 
 
14546 
  def __eq__(self, other):
14547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14548 
 
14549 
  def __ne__(self, other):
14550 
    return not (self == other)
14551 
 
2536 chandransh 14552 
class requestPickupNumber_args:
14553 
  """
14554 
  Attributes:
14555 
   - orderId
4579 rajveer 14556 
   - providerId
2536 chandransh 14557 
  """
14558 
 
14559 
  thrift_spec = (
14560 
    None, # 0
14561 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 14562 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 14563 
  )
14564 
 
4579 rajveer 14565 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 14566 
    self.orderId = orderId
4579 rajveer 14567 
    self.providerId = providerId
2536 chandransh 14568 
 
14569 
  def read(self, iprot):
14570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14572 
      return
14573 
    iprot.readStructBegin()
14574 
    while True:
14575 
      (fname, ftype, fid) = iprot.readFieldBegin()
14576 
      if ftype == TType.STOP:
14577 
        break
14578 
      if fid == 1:
14579 
        if ftype == TType.I64:
14580 
          self.orderId = iprot.readI64();
14581 
        else:
14582 
          iprot.skip(ftype)
4579 rajveer 14583 
      elif fid == 2:
14584 
        if ftype == TType.I64:
14585 
          self.providerId = iprot.readI64();
14586 
        else:
14587 
          iprot.skip(ftype)
2536 chandransh 14588 
      else:
14589 
        iprot.skip(ftype)
14590 
      iprot.readFieldEnd()
14591 
    iprot.readStructEnd()
14592 
 
14593 
  def write(self, oprot):
14594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14596 
      return
14597 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 14598 
    if self.orderId is not None:
2536 chandransh 14599 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14600 
      oprot.writeI64(self.orderId)
14601 
      oprot.writeFieldEnd()
4579 rajveer 14602 
    if self.providerId is not None:
14603 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
14604 
      oprot.writeI64(self.providerId)
14605 
      oprot.writeFieldEnd()
2536 chandransh 14606 
    oprot.writeFieldStop()
14607 
    oprot.writeStructEnd()
14608 
 
3431 rajveer 14609 
  def validate(self):
14610 
    return
14611 
 
14612 
 
2536 chandransh 14613 
  def __repr__(self):
14614 
    L = ['%s=%r' % (key, value)
14615 
      for key, value in self.__dict__.iteritems()]
14616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14617 
 
14618 
  def __eq__(self, other):
14619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14620 
 
14621 
  def __ne__(self, other):
14622 
    return not (self == other)
14623 
 
14624 
class requestPickupNumber_result:
14625 
  """
14626 
  Attributes:
14627 
   - success
14628 
   - ex
14629 
  """
14630 
 
14631 
  thrift_spec = (
14632 
    (0, TType.BOOL, 'success', None, None, ), # 0
14633 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14634 
  )
14635 
 
14636 
  def __init__(self, success=None, ex=None,):
14637 
    self.success = success
14638 
    self.ex = ex
14639 
 
14640 
  def read(self, iprot):
14641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14643 
      return
14644 
    iprot.readStructBegin()
14645 
    while True:
14646 
      (fname, ftype, fid) = iprot.readFieldBegin()
14647 
      if ftype == TType.STOP:
14648 
        break
14649 
      if fid == 0:
14650 
        if ftype == TType.BOOL:
14651 
          self.success = iprot.readBool();
14652 
        else:
14653 
          iprot.skip(ftype)
14654 
      elif fid == 1:
14655 
        if ftype == TType.STRUCT:
14656 
          self.ex = TransactionServiceException()
14657 
          self.ex.read(iprot)
14658 
        else:
14659 
          iprot.skip(ftype)
14660 
      else:
14661 
        iprot.skip(ftype)
14662 
      iprot.readFieldEnd()
14663 
    iprot.readStructEnd()
14664 
 
14665 
  def write(self, oprot):
14666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14668 
      return
14669 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 14670 
    if self.success is not None:
2536 chandransh 14671 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14672 
      oprot.writeBool(self.success)
14673 
      oprot.writeFieldEnd()
3431 rajveer 14674 
    if self.ex is not None:
2536 chandransh 14675 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14676 
      self.ex.write(oprot)
14677 
      oprot.writeFieldEnd()
14678 
    oprot.writeFieldStop()
14679 
    oprot.writeStructEnd()
14680 
 
3431 rajveer 14681 
  def validate(self):
14682 
    return
14683 
 
14684 
 
2536 chandransh 14685 
  def __repr__(self):
14686 
    L = ['%s=%r' % (key, value)
14687 
      for key, value in self.__dict__.iteritems()]
14688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14689 
 
14690 
  def __eq__(self, other):
14691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14692 
 
14693 
  def __ne__(self, other):
14694 
    return not (self == other)
14695 
 
14696 
class authorizePickup_args:
14697 
  """
14698 
  Attributes:
14699 
   - orderId
14700 
   - pickupNumber
4602 rajveer 14701 
   - providerId
2536 chandransh 14702 
  """
14703 
 
14704 
  thrift_spec = (
14705 
    None, # 0
14706 
    (1, TType.I64, 'orderId', None, None, ), # 1
14707 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 14708 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 14709 
  )
14710 
 
4602 rajveer 14711 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 14712 
    self.orderId = orderId
14713 
    self.pickupNumber = pickupNumber
4602 rajveer 14714 
    self.providerId = providerId
2536 chandransh 14715 
 
14716 
  def read(self, iprot):
14717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14719 
      return
14720 
    iprot.readStructBegin()
14721 
    while True:
14722 
      (fname, ftype, fid) = iprot.readFieldBegin()
14723 
      if ftype == TType.STOP:
14724 
        break
14725 
      if fid == 1:
14726 
        if ftype == TType.I64:
14727 
          self.orderId = iprot.readI64();
14728 
        else:
14729 
          iprot.skip(ftype)
14730 
      elif fid == 2:
14731 
        if ftype == TType.STRING:
14732 
          self.pickupNumber = iprot.readString();
14733 
        else:
14734 
          iprot.skip(ftype)
4602 rajveer 14735 
      elif fid == 3:
14736 
        if ftype == TType.I64:
14737 
          self.providerId = iprot.readI64();
14738 
        else:
14739 
          iprot.skip(ftype)
2536 chandransh 14740 
      else:
14741 
        iprot.skip(ftype)
14742 
      iprot.readFieldEnd()
14743 
    iprot.readStructEnd()
14744 
 
14745 
  def write(self, oprot):
14746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14748 
      return
14749 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 14750 
    if self.orderId is not None:
2536 chandransh 14751 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14752 
      oprot.writeI64(self.orderId)
14753 
      oprot.writeFieldEnd()
3431 rajveer 14754 
    if self.pickupNumber is not None:
2536 chandransh 14755 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
14756 
      oprot.writeString(self.pickupNumber)
14757 
      oprot.writeFieldEnd()
4602 rajveer 14758 
    if self.providerId is not None:
14759 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
14760 
      oprot.writeI64(self.providerId)
14761 
      oprot.writeFieldEnd()
2536 chandransh 14762 
    oprot.writeFieldStop()
14763 
    oprot.writeStructEnd()
14764 
 
3431 rajveer 14765 
  def validate(self):
14766 
    return
14767 
 
14768 
 
2536 chandransh 14769 
  def __repr__(self):
14770 
    L = ['%s=%r' % (key, value)
14771 
      for key, value in self.__dict__.iteritems()]
14772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14773 
 
14774 
  def __eq__(self, other):
14775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14776 
 
14777 
  def __ne__(self, other):
14778 
    return not (self == other)
14779 
 
14780 
class authorizePickup_result:
14781 
  """
14782 
  Attributes:
14783 
   - success
14784 
   - ex
14785 
  """
14786 
 
14787 
  thrift_spec = (
14788 
    (0, TType.BOOL, 'success', None, None, ), # 0
14789 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14790 
  )
14791 
 
14792 
  def __init__(self, success=None, ex=None,):
14793 
    self.success = success
14794 
    self.ex = ex
14795 
 
14796 
  def read(self, iprot):
14797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14799 
      return
14800 
    iprot.readStructBegin()
14801 
    while True:
14802 
      (fname, ftype, fid) = iprot.readFieldBegin()
14803 
      if ftype == TType.STOP:
14804 
        break
14805 
      if fid == 0:
14806 
        if ftype == TType.BOOL:
14807 
          self.success = iprot.readBool();
14808 
        else:
14809 
          iprot.skip(ftype)
14810 
      elif fid == 1:
14811 
        if ftype == TType.STRUCT:
14812 
          self.ex = TransactionServiceException()
14813 
          self.ex.read(iprot)
14814 
        else:
14815 
          iprot.skip(ftype)
14816 
      else:
14817 
        iprot.skip(ftype)
14818 
      iprot.readFieldEnd()
14819 
    iprot.readStructEnd()
14820 
 
14821 
  def write(self, oprot):
14822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14824 
      return
14825 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 14826 
    if self.success is not None:
2536 chandransh 14827 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14828 
      oprot.writeBool(self.success)
14829 
      oprot.writeFieldEnd()
3431 rajveer 14830 
    if self.ex is not None:
2536 chandransh 14831 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14832 
      self.ex.write(oprot)
14833 
      oprot.writeFieldEnd()
14834 
    oprot.writeFieldStop()
14835 
    oprot.writeStructEnd()
14836 
 
3431 rajveer 14837 
  def validate(self):
14838 
    return
14839 
 
14840 
 
2536 chandransh 14841 
  def __repr__(self):
14842 
    L = ['%s=%r' % (key, value)
14843 
      for key, value in self.__dict__.iteritems()]
14844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14845 
 
14846 
  def __eq__(self, other):
14847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14848 
 
14849 
  def __ne__(self, other):
14850 
    return not (self == other)
14851 
 
2764 chandransh 14852 
class markDoasAsPickedUp_args:
14853 
  """
14854 
  Attributes:
14855 
   - providerId
14856 
   - pickupDetails
14857 
  """
14858 
 
14859 
  thrift_spec = (
14860 
    None, # 0
14861 
    (1, TType.I64, 'providerId', None, None, ), # 1
14862 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
14863 
  )
14864 
 
14865 
  def __init__(self, providerId=None, pickupDetails=None,):
14866 
    self.providerId = providerId
14867 
    self.pickupDetails = pickupDetails
14868 
 
14869 
  def read(self, iprot):
14870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14872 
      return
14873 
    iprot.readStructBegin()
14874 
    while True:
14875 
      (fname, ftype, fid) = iprot.readFieldBegin()
14876 
      if ftype == TType.STOP:
14877 
        break
14878 
      if fid == 1:
14879 
        if ftype == TType.I64:
14880 
          self.providerId = iprot.readI64();
14881 
        else:
14882 
          iprot.skip(ftype)
14883 
      elif fid == 2:
14884 
        if ftype == TType.MAP:
14885 
          self.pickupDetails = {}
5031 varun.gupt 14886 
          (_ktype323, _vtype324, _size322 ) = iprot.readMapBegin()
14887 
          for _i326 in xrange(_size322):
14888 
            _key327 = iprot.readString();
14889 
            _val328 = iprot.readString();
14890 
            self.pickupDetails[_key327] = _val328
2764 chandransh 14891 
          iprot.readMapEnd()
14892 
        else:
14893 
          iprot.skip(ftype)
14894 
      else:
14895 
        iprot.skip(ftype)
14896 
      iprot.readFieldEnd()
14897 
    iprot.readStructEnd()
14898 
 
14899 
  def write(self, oprot):
14900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14902 
      return
14903 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 14904 
    if self.providerId is not None:
2764 chandransh 14905 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14906 
      oprot.writeI64(self.providerId)
14907 
      oprot.writeFieldEnd()
3431 rajveer 14908 
    if self.pickupDetails is not None:
2764 chandransh 14909 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14910 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 14911 
      for kiter329,viter330 in self.pickupDetails.items():
14912 
        oprot.writeString(kiter329)
14913 
        oprot.writeString(viter330)
2764 chandransh 14914 
      oprot.writeMapEnd()
14915 
      oprot.writeFieldEnd()
14916 
    oprot.writeFieldStop()
14917 
    oprot.writeStructEnd()
14918 
 
3431 rajveer 14919 
  def validate(self):
14920 
    return
14921 
 
14922 
 
2764 chandransh 14923 
  def __repr__(self):
14924 
    L = ['%s=%r' % (key, value)
14925 
      for key, value in self.__dict__.iteritems()]
14926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14927 
 
14928 
  def __eq__(self, other):
14929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14930 
 
14931 
  def __ne__(self, other):
14932 
    return not (self == other)
14933 
 
14934 
class markDoasAsPickedUp_result:
4910 phani.kuma 14935 
 
14936 
  thrift_spec = (
14937 
  )
14938 
 
14939 
  def read(self, iprot):
14940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14942 
      return
14943 
    iprot.readStructBegin()
14944 
    while True:
14945 
      (fname, ftype, fid) = iprot.readFieldBegin()
14946 
      if ftype == TType.STOP:
14947 
        break
14948 
      else:
14949 
        iprot.skip(ftype)
14950 
      iprot.readFieldEnd()
14951 
    iprot.readStructEnd()
14952 
 
14953 
  def write(self, oprot):
14954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14956 
      return
14957 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
14958 
    oprot.writeFieldStop()
14959 
    oprot.writeStructEnd()
14960 
 
14961 
  def validate(self):
14962 
    return
14963 
 
14964 
 
14965 
  def __repr__(self):
14966 
    L = ['%s=%r' % (key, value)
14967 
      for key, value in self.__dict__.iteritems()]
14968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14969 
 
14970 
  def __eq__(self, other):
14971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14972 
 
14973 
  def __ne__(self, other):
14974 
    return not (self == other)
14975 
 
14976 
class getDoasNotPickedUp_args:
2764 chandransh 14977 
  """
14978 
  Attributes:
4910 phani.kuma 14979 
   - providerId
14980 
  """
14981 
 
14982 
  thrift_spec = (
14983 
    None, # 0
14984 
    (1, TType.I64, 'providerId', None, None, ), # 1
14985 
  )
14986 
 
14987 
  def __init__(self, providerId=None,):
14988 
    self.providerId = providerId
14989 
 
14990 
  def read(self, iprot):
14991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14993 
      return
14994 
    iprot.readStructBegin()
14995 
    while True:
14996 
      (fname, ftype, fid) = iprot.readFieldBegin()
14997 
      if ftype == TType.STOP:
14998 
        break
14999 
      if fid == 1:
15000 
        if ftype == TType.I64:
15001 
          self.providerId = iprot.readI64();
15002 
        else:
15003 
          iprot.skip(ftype)
15004 
      else:
15005 
        iprot.skip(ftype)
15006 
      iprot.readFieldEnd()
15007 
    iprot.readStructEnd()
15008 
 
15009 
  def write(self, oprot):
15010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15012 
      return
15013 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
15014 
    if self.providerId is not None:
15015 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15016 
      oprot.writeI64(self.providerId)
15017 
      oprot.writeFieldEnd()
15018 
    oprot.writeFieldStop()
15019 
    oprot.writeStructEnd()
15020 
 
15021 
  def validate(self):
15022 
    return
15023 
 
15024 
 
15025 
  def __repr__(self):
15026 
    L = ['%s=%r' % (key, value)
15027 
      for key, value in self.__dict__.iteritems()]
15028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15029 
 
15030 
  def __eq__(self, other):
15031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15032 
 
15033 
  def __ne__(self, other):
15034 
    return not (self == other)
15035 
 
15036 
class getDoasNotPickedUp_result:
15037 
  """
15038 
  Attributes:
2764 chandransh 15039 
   - success
15040 
  """
15041 
 
15042 
  thrift_spec = (
15043 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15044 
  )
15045 
 
15046 
  def __init__(self, success=None,):
15047 
    self.success = success
15048 
 
15049 
  def read(self, iprot):
15050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15052 
      return
15053 
    iprot.readStructBegin()
15054 
    while True:
15055 
      (fname, ftype, fid) = iprot.readFieldBegin()
15056 
      if ftype == TType.STOP:
15057 
        break
15058 
      if fid == 0:
15059 
        if ftype == TType.LIST:
15060 
          self.success = []
5031 varun.gupt 15061 
          (_etype334, _size331) = iprot.readListBegin()
15062 
          for _i335 in xrange(_size331):
15063 
            _elem336 = Order()
15064 
            _elem336.read(iprot)
15065 
            self.success.append(_elem336)
2764 chandransh 15066 
          iprot.readListEnd()
15067 
        else:
15068 
          iprot.skip(ftype)
15069 
      else:
15070 
        iprot.skip(ftype)
15071 
      iprot.readFieldEnd()
15072 
    iprot.readStructEnd()
15073 
 
15074 
  def write(self, oprot):
15075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15077 
      return
4910 phani.kuma 15078 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 15079 
    if self.success is not None:
2764 chandransh 15080 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15081 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 15082 
      for iter337 in self.success:
15083 
        iter337.write(oprot)
2764 chandransh 15084 
      oprot.writeListEnd()
15085 
      oprot.writeFieldEnd()
15086 
    oprot.writeFieldStop()
15087 
    oprot.writeStructEnd()
15088 
 
3431 rajveer 15089 
  def validate(self):
15090 
    return
15091 
 
15092 
 
2764 chandransh 15093 
  def __repr__(self):
15094 
    L = ['%s=%r' % (key, value)
15095 
      for key, value in self.__dict__.iteritems()]
15096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15097 
 
15098 
  def __eq__(self, other):
15099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15100 
 
15101 
  def __ne__(self, other):
15102 
    return not (self == other)
15103 
 
4741 phani.kuma 15104 
class markReturnOrdersAsPickedUp_args:
15105 
  """
15106 
  Attributes:
15107 
   - providerId
15108 
   - pickupDetails
15109 
  """
15110 
 
15111 
  thrift_spec = (
15112 
    None, # 0
15113 
    (1, TType.I64, 'providerId', None, None, ), # 1
15114 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
15115 
  )
15116 
 
15117 
  def __init__(self, providerId=None, pickupDetails=None,):
15118 
    self.providerId = providerId
15119 
    self.pickupDetails = pickupDetails
15120 
 
15121 
  def read(self, iprot):
15122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15124 
      return
15125 
    iprot.readStructBegin()
15126 
    while True:
15127 
      (fname, ftype, fid) = iprot.readFieldBegin()
15128 
      if ftype == TType.STOP:
15129 
        break
15130 
      if fid == 1:
15131 
        if ftype == TType.I64:
15132 
          self.providerId = iprot.readI64();
15133 
        else:
15134 
          iprot.skip(ftype)
15135 
      elif fid == 2:
15136 
        if ftype == TType.MAP:
15137 
          self.pickupDetails = {}
5031 varun.gupt 15138 
          (_ktype339, _vtype340, _size338 ) = iprot.readMapBegin()
15139 
          for _i342 in xrange(_size338):
15140 
            _key343 = iprot.readString();
15141 
            _val344 = iprot.readString();
15142 
            self.pickupDetails[_key343] = _val344
4741 phani.kuma 15143 
          iprot.readMapEnd()
15144 
        else:
15145 
          iprot.skip(ftype)
15146 
      else:
15147 
        iprot.skip(ftype)
15148 
      iprot.readFieldEnd()
15149 
    iprot.readStructEnd()
15150 
 
15151 
  def write(self, oprot):
15152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15154 
      return
15155 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
15156 
    if self.providerId is not None:
15157 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15158 
      oprot.writeI64(self.providerId)
15159 
      oprot.writeFieldEnd()
15160 
    if self.pickupDetails is not None:
15161 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15162 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 15163 
      for kiter345,viter346 in self.pickupDetails.items():
15164 
        oprot.writeString(kiter345)
15165 
        oprot.writeString(viter346)
4741 phani.kuma 15166 
      oprot.writeMapEnd()
15167 
      oprot.writeFieldEnd()
15168 
    oprot.writeFieldStop()
15169 
    oprot.writeStructEnd()
15170 
 
15171 
  def validate(self):
15172 
    return
15173 
 
15174 
 
15175 
  def __repr__(self):
15176 
    L = ['%s=%r' % (key, value)
15177 
      for key, value in self.__dict__.iteritems()]
15178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15179 
 
15180 
  def __eq__(self, other):
15181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15182 
 
15183 
  def __ne__(self, other):
15184 
    return not (self == other)
15185 
 
15186 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 15187 
 
15188 
  thrift_spec = (
15189 
  )
15190 
 
15191 
  def read(self, iprot):
15192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15194 
      return
15195 
    iprot.readStructBegin()
15196 
    while True:
15197 
      (fname, ftype, fid) = iprot.readFieldBegin()
15198 
      if ftype == TType.STOP:
15199 
        break
15200 
      else:
15201 
        iprot.skip(ftype)
15202 
      iprot.readFieldEnd()
15203 
    iprot.readStructEnd()
15204 
 
15205 
  def write(self, oprot):
15206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15208 
      return
15209 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
15210 
    oprot.writeFieldStop()
15211 
    oprot.writeStructEnd()
15212 
 
15213 
  def validate(self):
15214 
    return
15215 
 
15216 
 
15217 
  def __repr__(self):
15218 
    L = ['%s=%r' % (key, value)
15219 
      for key, value in self.__dict__.iteritems()]
15220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15221 
 
15222 
  def __eq__(self, other):
15223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15224 
 
15225 
  def __ne__(self, other):
15226 
    return not (self == other)
15227 
 
15228 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 15229 
  """
15230 
  Attributes:
4910 phani.kuma 15231 
   - providerId
15232 
  """
15233 
 
15234 
  thrift_spec = (
15235 
    None, # 0
15236 
    (1, TType.I64, 'providerId', None, None, ), # 1
15237 
  )
15238 
 
15239 
  def __init__(self, providerId=None,):
15240 
    self.providerId = providerId
15241 
 
15242 
  def read(self, iprot):
15243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15245 
      return
15246 
    iprot.readStructBegin()
15247 
    while True:
15248 
      (fname, ftype, fid) = iprot.readFieldBegin()
15249 
      if ftype == TType.STOP:
15250 
        break
15251 
      if fid == 1:
15252 
        if ftype == TType.I64:
15253 
          self.providerId = iprot.readI64();
15254 
        else:
15255 
          iprot.skip(ftype)
15256 
      else:
15257 
        iprot.skip(ftype)
15258 
      iprot.readFieldEnd()
15259 
    iprot.readStructEnd()
15260 
 
15261 
  def write(self, oprot):
15262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15264 
      return
15265 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
15266 
    if self.providerId is not None:
15267 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15268 
      oprot.writeI64(self.providerId)
15269 
      oprot.writeFieldEnd()
15270 
    oprot.writeFieldStop()
15271 
    oprot.writeStructEnd()
15272 
 
15273 
  def validate(self):
15274 
    return
15275 
 
15276 
 
15277 
  def __repr__(self):
15278 
    L = ['%s=%r' % (key, value)
15279 
      for key, value in self.__dict__.iteritems()]
15280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15281 
 
15282 
  def __eq__(self, other):
15283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15284 
 
15285 
  def __ne__(self, other):
15286 
    return not (self == other)
15287 
 
15288 
class getReturnOrdersNotPickedUp_result:
15289 
  """
15290 
  Attributes:
4741 phani.kuma 15291 
   - success
15292 
  """
15293 
 
15294 
  thrift_spec = (
15295 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15296 
  )
15297 
 
15298 
  def __init__(self, success=None,):
15299 
    self.success = success
15300 
 
15301 
  def read(self, iprot):
15302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15304 
      return
15305 
    iprot.readStructBegin()
15306 
    while True:
15307 
      (fname, ftype, fid) = iprot.readFieldBegin()
15308 
      if ftype == TType.STOP:
15309 
        break
15310 
      if fid == 0:
15311 
        if ftype == TType.LIST:
15312 
          self.success = []
5031 varun.gupt 15313 
          (_etype350, _size347) = iprot.readListBegin()
15314 
          for _i351 in xrange(_size347):
15315 
            _elem352 = Order()
15316 
            _elem352.read(iprot)
15317 
            self.success.append(_elem352)
4741 phani.kuma 15318 
          iprot.readListEnd()
15319 
        else:
15320 
          iprot.skip(ftype)
15321 
      else:
15322 
        iprot.skip(ftype)
15323 
      iprot.readFieldEnd()
15324 
    iprot.readStructEnd()
15325 
 
15326 
  def write(self, oprot):
15327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15329 
      return
4910 phani.kuma 15330 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 15331 
    if self.success is not None:
15332 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15333 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 15334 
      for iter353 in self.success:
15335 
        iter353.write(oprot)
4741 phani.kuma 15336 
      oprot.writeListEnd()
15337 
      oprot.writeFieldEnd()
15338 
    oprot.writeFieldStop()
15339 
    oprot.writeStructEnd()
15340 
 
15341 
  def validate(self):
15342 
    return
15343 
 
15344 
 
15345 
  def __repr__(self):
15346 
    L = ['%s=%r' % (key, value)
15347 
      for key, value in self.__dict__.iteritems()]
15348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15349 
 
15350 
  def __eq__(self, other):
15351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15352 
 
15353 
  def __ne__(self, other):
15354 
    return not (self == other)
15355 
 
2616 chandransh 15356 
class receiveReturn_args:
2591 chandransh 15357 
  """
15358 
  Attributes:
15359 
   - orderId
4479 rajveer 15360 
   - receiveCondition
2591 chandransh 15361 
  """
2536 chandransh 15362 
 
2591 chandransh 15363 
  thrift_spec = (
15364 
    None, # 0
15365 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 15366 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 15367 
  )
15368 
 
4479 rajveer 15369 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 15370 
    self.orderId = orderId
4479 rajveer 15371 
    self.receiveCondition = receiveCondition
2591 chandransh 15372 
 
15373 
  def read(self, iprot):
15374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15376 
      return
15377 
    iprot.readStructBegin()
15378 
    while True:
15379 
      (fname, ftype, fid) = iprot.readFieldBegin()
15380 
      if ftype == TType.STOP:
15381 
        break
15382 
      if fid == 1:
15383 
        if ftype == TType.I64:
15384 
          self.orderId = iprot.readI64();
15385 
        else:
15386 
          iprot.skip(ftype)
4479 rajveer 15387 
      elif fid == 2:
15388 
        if ftype == TType.I64:
15389 
          self.receiveCondition = iprot.readI64();
15390 
        else:
15391 
          iprot.skip(ftype)
2591 chandransh 15392 
      else:
15393 
        iprot.skip(ftype)
15394 
      iprot.readFieldEnd()
15395 
    iprot.readStructEnd()
15396 
 
15397 
  def write(self, oprot):
15398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15400 
      return
2616 chandransh 15401 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 15402 
    if self.orderId is not None:
2591 chandransh 15403 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15404 
      oprot.writeI64(self.orderId)
15405 
      oprot.writeFieldEnd()
4479 rajveer 15406 
    if self.receiveCondition is not None:
15407 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
15408 
      oprot.writeI64(self.receiveCondition)
15409 
      oprot.writeFieldEnd()
2591 chandransh 15410 
    oprot.writeFieldStop()
15411 
    oprot.writeStructEnd()
15412 
 
3431 rajveer 15413 
  def validate(self):
15414 
    return
15415 
 
15416 
 
2591 chandransh 15417 
  def __repr__(self):
15418 
    L = ['%s=%r' % (key, value)
15419 
      for key, value in self.__dict__.iteritems()]
15420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15421 
 
15422 
  def __eq__(self, other):
15423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15424 
 
15425 
  def __ne__(self, other):
15426 
    return not (self == other)
15427 
 
2616 chandransh 15428 
class receiveReturn_result:
2591 chandransh 15429 
  """
15430 
  Attributes:
15431 
   - success
15432 
   - ex
15433 
  """
15434 
 
15435 
  thrift_spec = (
15436 
    (0, TType.BOOL, 'success', None, None, ), # 0
15437 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15438 
  )
15439 
 
15440 
  def __init__(self, success=None, ex=None,):
15441 
    self.success = success
15442 
    self.ex = ex
15443 
 
15444 
  def read(self, iprot):
15445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15447 
      return
15448 
    iprot.readStructBegin()
15449 
    while True:
15450 
      (fname, ftype, fid) = iprot.readFieldBegin()
15451 
      if ftype == TType.STOP:
15452 
        break
15453 
      if fid == 0:
15454 
        if ftype == TType.BOOL:
15455 
          self.success = iprot.readBool();
15456 
        else:
15457 
          iprot.skip(ftype)
15458 
      elif fid == 1:
15459 
        if ftype == TType.STRUCT:
15460 
          self.ex = TransactionServiceException()
15461 
          self.ex.read(iprot)
15462 
        else:
15463 
          iprot.skip(ftype)
15464 
      else:
15465 
        iprot.skip(ftype)
15466 
      iprot.readFieldEnd()
15467 
    iprot.readStructEnd()
15468 
 
15469 
  def write(self, oprot):
15470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15472 
      return
2616 chandransh 15473 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 15474 
    if self.success is not None:
2591 chandransh 15475 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15476 
      oprot.writeBool(self.success)
15477 
      oprot.writeFieldEnd()
3431 rajveer 15478 
    if self.ex is not None:
2591 chandransh 15479 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15480 
      self.ex.write(oprot)
15481 
      oprot.writeFieldEnd()
15482 
    oprot.writeFieldStop()
15483 
    oprot.writeStructEnd()
15484 
 
3431 rajveer 15485 
  def validate(self):
15486 
    return
15487 
 
15488 
 
2591 chandransh 15489 
  def __repr__(self):
15490 
    L = ['%s=%r' % (key, value)
15491 
      for key, value in self.__dict__.iteritems()]
15492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15493 
 
15494 
  def __eq__(self, other):
15495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15496 
 
15497 
  def __ne__(self, other):
15498 
    return not (self == other)
15499 
 
15500 
class validateDoa_args:
15501 
  """
15502 
  Attributes:
15503 
   - orderId
15504 
   - isValid
15505 
  """
15506 
 
15507 
  thrift_spec = (
15508 
    None, # 0
15509 
    (1, TType.I64, 'orderId', None, None, ), # 1
15510 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
15511 
  )
15512 
 
15513 
  def __init__(self, orderId=None, isValid=None,):
15514 
    self.orderId = orderId
15515 
    self.isValid = isValid
15516 
 
15517 
  def read(self, iprot):
15518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15520 
      return
15521 
    iprot.readStructBegin()
15522 
    while True:
15523 
      (fname, ftype, fid) = iprot.readFieldBegin()
15524 
      if ftype == TType.STOP:
15525 
        break
15526 
      if fid == 1:
15527 
        if ftype == TType.I64:
15528 
          self.orderId = iprot.readI64();
15529 
        else:
15530 
          iprot.skip(ftype)
15531 
      elif fid == 2:
15532 
        if ftype == TType.BOOL:
15533 
          self.isValid = iprot.readBool();
15534 
        else:
15535 
          iprot.skip(ftype)
15536 
      else:
15537 
        iprot.skip(ftype)
15538 
      iprot.readFieldEnd()
15539 
    iprot.readStructEnd()
15540 
 
15541 
  def write(self, oprot):
15542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15544 
      return
15545 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 15546 
    if self.orderId is not None:
2591 chandransh 15547 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15548 
      oprot.writeI64(self.orderId)
15549 
      oprot.writeFieldEnd()
3431 rajveer 15550 
    if self.isValid is not None:
2591 chandransh 15551 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
15552 
      oprot.writeBool(self.isValid)
15553 
      oprot.writeFieldEnd()
15554 
    oprot.writeFieldStop()
15555 
    oprot.writeStructEnd()
15556 
 
3431 rajveer 15557 
  def validate(self):
15558 
    return
15559 
 
15560 
 
2591 chandransh 15561 
  def __repr__(self):
15562 
    L = ['%s=%r' % (key, value)
15563 
      for key, value in self.__dict__.iteritems()]
15564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15565 
 
15566 
  def __eq__(self, other):
15567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15568 
 
15569 
  def __ne__(self, other):
15570 
    return not (self == other)
15571 
 
15572 
class validateDoa_result:
15573 
  """
15574 
  Attributes:
15575 
   - success
15576 
   - ex
15577 
  """
15578 
 
15579 
  thrift_spec = (
15580 
    (0, TType.BOOL, 'success', None, None, ), # 0
15581 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15582 
  )
15583 
 
15584 
  def __init__(self, success=None, ex=None,):
15585 
    self.success = success
15586 
    self.ex = ex
15587 
 
15588 
  def read(self, iprot):
15589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15591 
      return
15592 
    iprot.readStructBegin()
15593 
    while True:
15594 
      (fname, ftype, fid) = iprot.readFieldBegin()
15595 
      if ftype == TType.STOP:
15596 
        break
15597 
      if fid == 0:
15598 
        if ftype == TType.BOOL:
15599 
          self.success = iprot.readBool();
15600 
        else:
15601 
          iprot.skip(ftype)
15602 
      elif fid == 1:
15603 
        if ftype == TType.STRUCT:
15604 
          self.ex = TransactionServiceException()
15605 
          self.ex.read(iprot)
15606 
        else:
15607 
          iprot.skip(ftype)
15608 
      else:
15609 
        iprot.skip(ftype)
15610 
      iprot.readFieldEnd()
15611 
    iprot.readStructEnd()
15612 
 
15613 
  def write(self, oprot):
15614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15616 
      return
15617 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 15618 
    if self.success is not None:
2591 chandransh 15619 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15620 
      oprot.writeBool(self.success)
15621 
      oprot.writeFieldEnd()
3431 rajveer 15622 
    if self.ex is not None:
2591 chandransh 15623 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15624 
      self.ex.write(oprot)
15625 
      oprot.writeFieldEnd()
15626 
    oprot.writeFieldStop()
15627 
    oprot.writeStructEnd()
15628 
 
3431 rajveer 15629 
  def validate(self):
15630 
    return
15631 
 
15632 
 
2591 chandransh 15633 
  def __repr__(self):
15634 
    L = ['%s=%r' % (key, value)
15635 
      for key, value in self.__dict__.iteritems()]
15636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15637 
 
15638 
  def __eq__(self, other):
15639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15640 
 
15641 
  def __ne__(self, other):
15642 
    return not (self == other)
15643 
 
4495 rajveer 15644 
class validateReturnProduct_args:
15645 
  """
15646 
  Attributes:
15647 
   - orderId
15648 
   - isUsable
15649 
  """
15650 
 
15651 
  thrift_spec = (
15652 
    None, # 0
15653 
    (1, TType.I64, 'orderId', None, None, ), # 1
15654 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
15655 
  )
15656 
 
15657 
  def __init__(self, orderId=None, isUsable=None,):
15658 
    self.orderId = orderId
15659 
    self.isUsable = isUsable
15660 
 
15661 
  def read(self, iprot):
15662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15664 
      return
15665 
    iprot.readStructBegin()
15666 
    while True:
15667 
      (fname, ftype, fid) = iprot.readFieldBegin()
15668 
      if ftype == TType.STOP:
15669 
        break
15670 
      if fid == 1:
15671 
        if ftype == TType.I64:
15672 
          self.orderId = iprot.readI64();
15673 
        else:
15674 
          iprot.skip(ftype)
15675 
      elif fid == 2:
15676 
        if ftype == TType.BOOL:
15677 
          self.isUsable = iprot.readBool();
15678 
        else:
15679 
          iprot.skip(ftype)
15680 
      else:
15681 
        iprot.skip(ftype)
15682 
      iprot.readFieldEnd()
15683 
    iprot.readStructEnd()
15684 
 
15685 
  def write(self, oprot):
15686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15688 
      return
15689 
    oprot.writeStructBegin('validateReturnProduct_args')
15690 
    if self.orderId is not None:
15691 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15692 
      oprot.writeI64(self.orderId)
15693 
      oprot.writeFieldEnd()
15694 
    if self.isUsable is not None:
15695 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
15696 
      oprot.writeBool(self.isUsable)
15697 
      oprot.writeFieldEnd()
15698 
    oprot.writeFieldStop()
15699 
    oprot.writeStructEnd()
15700 
 
15701 
  def validate(self):
15702 
    return
15703 
 
15704 
 
15705 
  def __repr__(self):
15706 
    L = ['%s=%r' % (key, value)
15707 
      for key, value in self.__dict__.iteritems()]
15708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15709 
 
15710 
  def __eq__(self, other):
15711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15712 
 
15713 
  def __ne__(self, other):
15714 
    return not (self == other)
15715 
 
15716 
class validateReturnProduct_result:
15717 
  """
15718 
  Attributes:
15719 
   - success
15720 
   - ex
15721 
  """
15722 
 
15723 
  thrift_spec = (
15724 
    (0, TType.BOOL, 'success', None, None, ), # 0
15725 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15726 
  )
15727 
 
15728 
  def __init__(self, success=None, ex=None,):
15729 
    self.success = success
15730 
    self.ex = ex
15731 
 
15732 
  def read(self, iprot):
15733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15735 
      return
15736 
    iprot.readStructBegin()
15737 
    while True:
15738 
      (fname, ftype, fid) = iprot.readFieldBegin()
15739 
      if ftype == TType.STOP:
15740 
        break
15741 
      if fid == 0:
15742 
        if ftype == TType.BOOL:
15743 
          self.success = iprot.readBool();
15744 
        else:
15745 
          iprot.skip(ftype)
15746 
      elif fid == 1:
15747 
        if ftype == TType.STRUCT:
15748 
          self.ex = TransactionServiceException()
15749 
          self.ex.read(iprot)
15750 
        else:
15751 
          iprot.skip(ftype)
15752 
      else:
15753 
        iprot.skip(ftype)
15754 
      iprot.readFieldEnd()
15755 
    iprot.readStructEnd()
15756 
 
15757 
  def write(self, oprot):
15758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15760 
      return
15761 
    oprot.writeStructBegin('validateReturnProduct_result')
15762 
    if self.success is not None:
15763 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15764 
      oprot.writeBool(self.success)
15765 
      oprot.writeFieldEnd()
15766 
    if self.ex is not None:
15767 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15768 
      self.ex.write(oprot)
15769 
      oprot.writeFieldEnd()
15770 
    oprot.writeFieldStop()
15771 
    oprot.writeStructEnd()
15772 
 
15773 
  def validate(self):
15774 
    return
15775 
 
15776 
 
15777 
  def __repr__(self):
15778 
    L = ['%s=%r' % (key, value)
15779 
      for key, value in self.__dict__.iteritems()]
15780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15781 
 
15782 
  def __eq__(self, other):
15783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15784 
 
15785 
  def __ne__(self, other):
15786 
    return not (self == other)
15787 
 
2616 chandransh 15788 
class reshipOrder_args:
15789 
  """
15790 
  Attributes:
15791 
   - orderId
15792 
  """
2591 chandransh 15793 
 
2616 chandransh 15794 
  thrift_spec = (
15795 
    None, # 0
15796 
    (1, TType.I64, 'orderId', None, None, ), # 1
15797 
  )
15798 
 
15799 
  def __init__(self, orderId=None,):
15800 
    self.orderId = orderId
15801 
 
15802 
  def read(self, iprot):
15803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15805 
      return
15806 
    iprot.readStructBegin()
15807 
    while True:
15808 
      (fname, ftype, fid) = iprot.readFieldBegin()
15809 
      if ftype == TType.STOP:
15810 
        break
15811 
      if fid == 1:
15812 
        if ftype == TType.I64:
15813 
          self.orderId = iprot.readI64();
15814 
        else:
15815 
          iprot.skip(ftype)
15816 
      else:
15817 
        iprot.skip(ftype)
15818 
      iprot.readFieldEnd()
15819 
    iprot.readStructEnd()
15820 
 
15821 
  def write(self, oprot):
15822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15824 
      return
15825 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 15826 
    if self.orderId is not None:
2616 chandransh 15827 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15828 
      oprot.writeI64(self.orderId)
15829 
      oprot.writeFieldEnd()
15830 
    oprot.writeFieldStop()
15831 
    oprot.writeStructEnd()
15832 
 
3431 rajveer 15833 
  def validate(self):
15834 
    return
15835 
 
15836 
 
2616 chandransh 15837 
  def __repr__(self):
15838 
    L = ['%s=%r' % (key, value)
15839 
      for key, value in self.__dict__.iteritems()]
15840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15841 
 
15842 
  def __eq__(self, other):
15843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15844 
 
15845 
  def __ne__(self, other):
15846 
    return not (self == other)
15847 
 
15848 
class reshipOrder_result:
15849 
  """
15850 
  Attributes:
15851 
   - success
15852 
   - ex
15853 
  """
15854 
 
15855 
  thrift_spec = (
15856 
    (0, TType.I64, 'success', None, None, ), # 0
15857 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15858 
  )
15859 
 
15860 
  def __init__(self, success=None, ex=None,):
15861 
    self.success = success
15862 
    self.ex = ex
15863 
 
15864 
  def read(self, iprot):
15865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15867 
      return
15868 
    iprot.readStructBegin()
15869 
    while True:
15870 
      (fname, ftype, fid) = iprot.readFieldBegin()
15871 
      if ftype == TType.STOP:
15872 
        break
15873 
      if fid == 0:
15874 
        if ftype == TType.I64:
15875 
          self.success = iprot.readI64();
15876 
        else:
15877 
          iprot.skip(ftype)
15878 
      elif fid == 1:
15879 
        if ftype == TType.STRUCT:
15880 
          self.ex = TransactionServiceException()
15881 
          self.ex.read(iprot)
15882 
        else:
15883 
          iprot.skip(ftype)
15884 
      else:
15885 
        iprot.skip(ftype)
15886 
      iprot.readFieldEnd()
15887 
    iprot.readStructEnd()
15888 
 
15889 
  def write(self, oprot):
15890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15892 
      return
15893 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 15894 
    if self.success is not None:
2616 chandransh 15895 
      oprot.writeFieldBegin('success', TType.I64, 0)
15896 
      oprot.writeI64(self.success)
15897 
      oprot.writeFieldEnd()
3431 rajveer 15898 
    if self.ex is not None:
2616 chandransh 15899 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15900 
      self.ex.write(oprot)
15901 
      oprot.writeFieldEnd()
15902 
    oprot.writeFieldStop()
15903 
    oprot.writeStructEnd()
15904 
 
3431 rajveer 15905 
  def validate(self):
15906 
    return
15907 
 
15908 
 
2616 chandransh 15909 
  def __repr__(self):
15910 
    L = ['%s=%r' % (key, value)
15911 
      for key, value in self.__dict__.iteritems()]
15912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15913 
 
15914 
  def __eq__(self, other):
15915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15916 
 
15917 
  def __ne__(self, other):
15918 
    return not (self == other)
15919 
 
15920 
class refundOrder_args:
15921 
  """
15922 
  Attributes:
15923 
   - orderId
3226 chandransh 15924 
   - refundedBy
15925 
   - reason
2616 chandransh 15926 
  """
15927 
 
15928 
  thrift_spec = (
15929 
    None, # 0
15930 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 15931 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
15932 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 15933 
  )
15934 
 
3226 chandransh 15935 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 15936 
    self.orderId = orderId
3226 chandransh 15937 
    self.refundedBy = refundedBy
15938 
    self.reason = reason
2616 chandransh 15939 
 
15940 
  def read(self, iprot):
15941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15943 
      return
15944 
    iprot.readStructBegin()
15945 
    while True:
15946 
      (fname, ftype, fid) = iprot.readFieldBegin()
15947 
      if ftype == TType.STOP:
15948 
        break
15949 
      if fid == 1:
15950 
        if ftype == TType.I64:
15951 
          self.orderId = iprot.readI64();
15952 
        else:
15953 
          iprot.skip(ftype)
3226 chandransh 15954 
      elif fid == 2:
15955 
        if ftype == TType.STRING:
15956 
          self.refundedBy = iprot.readString();
15957 
        else:
15958 
          iprot.skip(ftype)
15959 
      elif fid == 3:
15960 
        if ftype == TType.STRING:
15961 
          self.reason = iprot.readString();
15962 
        else:
15963 
          iprot.skip(ftype)
2616 chandransh 15964 
      else:
15965 
        iprot.skip(ftype)
15966 
      iprot.readFieldEnd()
15967 
    iprot.readStructEnd()
15968 
 
15969 
  def write(self, oprot):
15970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15972 
      return
15973 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 15974 
    if self.orderId is not None:
2616 chandransh 15975 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15976 
      oprot.writeI64(self.orderId)
15977 
      oprot.writeFieldEnd()
3431 rajveer 15978 
    if self.refundedBy is not None:
3226 chandransh 15979 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
15980 
      oprot.writeString(self.refundedBy)
15981 
      oprot.writeFieldEnd()
3431 rajveer 15982 
    if self.reason is not None:
3226 chandransh 15983 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
15984 
      oprot.writeString(self.reason)
15985 
      oprot.writeFieldEnd()
2616 chandransh 15986 
    oprot.writeFieldStop()
15987 
    oprot.writeStructEnd()
15988 
 
3431 rajveer 15989 
  def validate(self):
15990 
    return
15991 
 
15992 
 
2616 chandransh 15993 
  def __repr__(self):
15994 
    L = ['%s=%r' % (key, value)
15995 
      for key, value in self.__dict__.iteritems()]
15996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15997 
 
15998 
  def __eq__(self, other):
15999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16000 
 
16001 
  def __ne__(self, other):
16002 
    return not (self == other)
16003 
 
16004 
class refundOrder_result:
16005 
  """
16006 
  Attributes:
16007 
   - success
16008 
   - ex
16009 
  """
16010 
 
16011 
  thrift_spec = (
16012 
    (0, TType.BOOL, 'success', None, None, ), # 0
16013 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16014 
  )
16015 
 
16016 
  def __init__(self, success=None, ex=None,):
16017 
    self.success = success
16018 
    self.ex = ex
16019 
 
16020 
  def read(self, iprot):
16021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16023 
      return
16024 
    iprot.readStructBegin()
16025 
    while True:
16026 
      (fname, ftype, fid) = iprot.readFieldBegin()
16027 
      if ftype == TType.STOP:
16028 
        break
16029 
      if fid == 0:
16030 
        if ftype == TType.BOOL:
16031 
          self.success = iprot.readBool();
16032 
        else:
16033 
          iprot.skip(ftype)
16034 
      elif fid == 1:
16035 
        if ftype == TType.STRUCT:
16036 
          self.ex = TransactionServiceException()
16037 
          self.ex.read(iprot)
16038 
        else:
16039 
          iprot.skip(ftype)
16040 
      else:
16041 
        iprot.skip(ftype)
16042 
      iprot.readFieldEnd()
16043 
    iprot.readStructEnd()
16044 
 
16045 
  def write(self, oprot):
16046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16048 
      return
16049 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 16050 
    if self.success is not None:
2616 chandransh 16051 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16052 
      oprot.writeBool(self.success)
16053 
      oprot.writeFieldEnd()
3431 rajveer 16054 
    if self.ex is not None:
2616 chandransh 16055 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16056 
      self.ex.write(oprot)
16057 
      oprot.writeFieldEnd()
16058 
    oprot.writeFieldStop()
16059 
    oprot.writeStructEnd()
16060 
 
3431 rajveer 16061 
  def validate(self):
16062 
    return
16063 
 
16064 
 
2616 chandransh 16065 
  def __repr__(self):
16066 
    L = ['%s=%r' % (key, value)
16067 
      for key, value in self.__dict__.iteritems()]
16068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16069 
 
16070 
  def __eq__(self, other):
16071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16072 
 
16073 
  def __ne__(self, other):
16074 
    return not (self == other)
16075 
 
2690 chandransh 16076 
class getReturnOrders_args:
16077 
  """
16078 
  Attributes:
16079 
   - warehouseId
16080 
   - fromDate
16081 
   - toDate
16082 
  """
2616 chandransh 16083 
 
2690 chandransh 16084 
  thrift_spec = (
16085 
    None, # 0
16086 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
16087 
    (2, TType.I64, 'fromDate', None, None, ), # 2
16088 
    (3, TType.I64, 'toDate', None, None, ), # 3
16089 
  )
16090 
 
16091 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
16092 
    self.warehouseId = warehouseId
16093 
    self.fromDate = fromDate
16094 
    self.toDate = toDate
16095 
 
16096 
  def read(self, iprot):
16097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16099 
      return
16100 
    iprot.readStructBegin()
16101 
    while True:
16102 
      (fname, ftype, fid) = iprot.readFieldBegin()
16103 
      if ftype == TType.STOP:
16104 
        break
16105 
      if fid == 1:
16106 
        if ftype == TType.I64:
16107 
          self.warehouseId = iprot.readI64();
16108 
        else:
16109 
          iprot.skip(ftype)
16110 
      elif fid == 2:
16111 
        if ftype == TType.I64:
16112 
          self.fromDate = iprot.readI64();
16113 
        else:
16114 
          iprot.skip(ftype)
16115 
      elif fid == 3:
16116 
        if ftype == TType.I64:
16117 
          self.toDate = iprot.readI64();
16118 
        else:
16119 
          iprot.skip(ftype)
16120 
      else:
16121 
        iprot.skip(ftype)
16122 
      iprot.readFieldEnd()
16123 
    iprot.readStructEnd()
16124 
 
16125 
  def write(self, oprot):
16126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16128 
      return
16129 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 16130 
    if self.warehouseId is not None:
2690 chandransh 16131 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
16132 
      oprot.writeI64(self.warehouseId)
16133 
      oprot.writeFieldEnd()
3431 rajveer 16134 
    if self.fromDate is not None:
2690 chandransh 16135 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
16136 
      oprot.writeI64(self.fromDate)
16137 
      oprot.writeFieldEnd()
3431 rajveer 16138 
    if self.toDate is not None:
2690 chandransh 16139 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
16140 
      oprot.writeI64(self.toDate)
16141 
      oprot.writeFieldEnd()
16142 
    oprot.writeFieldStop()
16143 
    oprot.writeStructEnd()
16144 
 
3431 rajveer 16145 
  def validate(self):
16146 
    return
16147 
 
16148 
 
2690 chandransh 16149 
  def __repr__(self):
16150 
    L = ['%s=%r' % (key, value)
16151 
      for key, value in self.__dict__.iteritems()]
16152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16153 
 
16154 
  def __eq__(self, other):
16155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16156 
 
16157 
  def __ne__(self, other):
16158 
    return not (self == other)
16159 
 
16160 
class getReturnOrders_result:
16161 
  """
16162 
  Attributes:
16163 
   - success
16164 
  """
16165 
 
16166 
  thrift_spec = (
16167 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
16168 
  )
16169 
 
16170 
  def __init__(self, success=None,):
16171 
    self.success = success
16172 
 
16173 
  def read(self, iprot):
16174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16176 
      return
16177 
    iprot.readStructBegin()
16178 
    while True:
16179 
      (fname, ftype, fid) = iprot.readFieldBegin()
16180 
      if ftype == TType.STOP:
16181 
        break
16182 
      if fid == 0:
16183 
        if ftype == TType.LIST:
16184 
          self.success = []
5031 varun.gupt 16185 
          (_etype357, _size354) = iprot.readListBegin()
16186 
          for _i358 in xrange(_size354):
16187 
            _elem359 = ReturnOrder()
16188 
            _elem359.read(iprot)
16189 
            self.success.append(_elem359)
2690 chandransh 16190 
          iprot.readListEnd()
16191 
        else:
16192 
          iprot.skip(ftype)
16193 
      else:
16194 
        iprot.skip(ftype)
16195 
      iprot.readFieldEnd()
16196 
    iprot.readStructEnd()
16197 
 
16198 
  def write(self, oprot):
16199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16201 
      return
16202 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 16203 
    if self.success is not None:
2690 chandransh 16204 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16205 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 16206 
      for iter360 in self.success:
16207 
        iter360.write(oprot)
2690 chandransh 16208 
      oprot.writeListEnd()
16209 
      oprot.writeFieldEnd()
16210 
    oprot.writeFieldStop()
16211 
    oprot.writeStructEnd()
16212 
 
3431 rajveer 16213 
  def validate(self):
16214 
    return
16215 
 
16216 
 
2690 chandransh 16217 
  def __repr__(self):
16218 
    L = ['%s=%r' % (key, value)
16219 
      for key, value in self.__dict__.iteritems()]
16220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16221 
 
16222 
  def __eq__(self, other):
16223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16224 
 
16225 
  def __ne__(self, other):
16226 
    return not (self == other)
16227 
 
2700 chandransh 16228 
class getReturnOrder_args:
16229 
  """
16230 
  Attributes:
16231 
   - id
16232 
  """
16233 
 
16234 
  thrift_spec = (
16235 
    None, # 0
16236 
    (1, TType.I64, 'id', None, None, ), # 1
16237 
  )
16238 
 
16239 
  def __init__(self, id=None,):
16240 
    self.id = id
16241 
 
16242 
  def read(self, iprot):
16243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16245 
      return
16246 
    iprot.readStructBegin()
16247 
    while True:
16248 
      (fname, ftype, fid) = iprot.readFieldBegin()
16249 
      if ftype == TType.STOP:
16250 
        break
16251 
      if fid == 1:
16252 
        if ftype == TType.I64:
16253 
          self.id = iprot.readI64();
16254 
        else:
16255 
          iprot.skip(ftype)
16256 
      else:
16257 
        iprot.skip(ftype)
16258 
      iprot.readFieldEnd()
16259 
    iprot.readStructEnd()
16260 
 
16261 
  def write(self, oprot):
16262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16264 
      return
16265 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 16266 
    if self.id is not None:
2700 chandransh 16267 
      oprot.writeFieldBegin('id', TType.I64, 1)
16268 
      oprot.writeI64(self.id)
16269 
      oprot.writeFieldEnd()
16270 
    oprot.writeFieldStop()
16271 
    oprot.writeStructEnd()
16272 
 
3431 rajveer 16273 
  def validate(self):
16274 
    return
16275 
 
16276 
 
2700 chandransh 16277 
  def __repr__(self):
16278 
    L = ['%s=%r' % (key, value)
16279 
      for key, value in self.__dict__.iteritems()]
16280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16281 
 
16282 
  def __eq__(self, other):
16283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16284 
 
16285 
  def __ne__(self, other):
16286 
    return not (self == other)
16287 
 
16288 
class getReturnOrder_result:
16289 
  """
16290 
  Attributes:
16291 
   - success
16292 
   - ex
16293 
  """
16294 
 
16295 
  thrift_spec = (
16296 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
16297 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16298 
  )
16299 
 
16300 
  def __init__(self, success=None, ex=None,):
16301 
    self.success = success
16302 
    self.ex = ex
16303 
 
16304 
  def read(self, iprot):
16305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16307 
      return
16308 
    iprot.readStructBegin()
16309 
    while True:
16310 
      (fname, ftype, fid) = iprot.readFieldBegin()
16311 
      if ftype == TType.STOP:
16312 
        break
16313 
      if fid == 0:
16314 
        if ftype == TType.STRUCT:
16315 
          self.success = ReturnOrder()
16316 
          self.success.read(iprot)
16317 
        else:
16318 
          iprot.skip(ftype)
16319 
      elif fid == 1:
16320 
        if ftype == TType.STRUCT:
16321 
          self.ex = TransactionServiceException()
16322 
          self.ex.read(iprot)
16323 
        else:
16324 
          iprot.skip(ftype)
16325 
      else:
16326 
        iprot.skip(ftype)
16327 
      iprot.readFieldEnd()
16328 
    iprot.readStructEnd()
16329 
 
16330 
  def write(self, oprot):
16331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16333 
      return
16334 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 16335 
    if self.success is not None:
2700 chandransh 16336 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16337 
      self.success.write(oprot)
16338 
      oprot.writeFieldEnd()
3431 rajveer 16339 
    if self.ex is not None:
2700 chandransh 16340 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16341 
      self.ex.write(oprot)
16342 
      oprot.writeFieldEnd()
16343 
    oprot.writeFieldStop()
16344 
    oprot.writeStructEnd()
16345 
 
3431 rajveer 16346 
  def validate(self):
16347 
    return
16348 
 
16349 
 
2700 chandransh 16350 
  def __repr__(self):
16351 
    L = ['%s=%r' % (key, value)
16352 
      for key, value in self.__dict__.iteritems()]
16353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16354 
 
16355 
  def __eq__(self, other):
16356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16357 
 
16358 
  def __ne__(self, other):
16359 
    return not (self == other)
16360 
 
2690 chandransh 16361 
class processReturn_args:
16362 
  """
16363 
  Attributes:
16364 
   - returnOrderId
16365 
  """
16366 
 
16367 
  thrift_spec = (
16368 
    None, # 0
16369 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
16370 
  )
16371 
 
16372 
  def __init__(self, returnOrderId=None,):
16373 
    self.returnOrderId = returnOrderId
16374 
 
16375 
  def read(self, iprot):
16376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16378 
      return
16379 
    iprot.readStructBegin()
16380 
    while True:
16381 
      (fname, ftype, fid) = iprot.readFieldBegin()
16382 
      if ftype == TType.STOP:
16383 
        break
16384 
      if fid == 1:
16385 
        if ftype == TType.I64:
16386 
          self.returnOrderId = iprot.readI64();
16387 
        else:
16388 
          iprot.skip(ftype)
16389 
      else:
16390 
        iprot.skip(ftype)
16391 
      iprot.readFieldEnd()
16392 
    iprot.readStructEnd()
16393 
 
16394 
  def write(self, oprot):
16395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16397 
      return
16398 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 16399 
    if self.returnOrderId is not None:
2690 chandransh 16400 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
16401 
      oprot.writeI64(self.returnOrderId)
16402 
      oprot.writeFieldEnd()
16403 
    oprot.writeFieldStop()
16404 
    oprot.writeStructEnd()
16405 
 
3431 rajveer 16406 
  def validate(self):
16407 
    return
16408 
 
16409 
 
2690 chandransh 16410 
  def __repr__(self):
16411 
    L = ['%s=%r' % (key, value)
16412 
      for key, value in self.__dict__.iteritems()]
16413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16414 
 
16415 
  def __eq__(self, other):
16416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16417 
 
16418 
  def __ne__(self, other):
16419 
    return not (self == other)
16420 
 
16421 
class processReturn_result:
16422 
  """
16423 
  Attributes:
16424 
   - ex
16425 
  """
16426 
 
16427 
  thrift_spec = (
16428 
    None, # 0
16429 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16430 
  )
16431 
 
16432 
  def __init__(self, ex=None,):
16433 
    self.ex = ex
16434 
 
16435 
  def read(self, iprot):
16436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16438 
      return
16439 
    iprot.readStructBegin()
16440 
    while True:
16441 
      (fname, ftype, fid) = iprot.readFieldBegin()
16442 
      if ftype == TType.STOP:
16443 
        break
16444 
      if fid == 1:
16445 
        if ftype == TType.STRUCT:
16446 
          self.ex = TransactionServiceException()
16447 
          self.ex.read(iprot)
16448 
        else:
16449 
          iprot.skip(ftype)
16450 
      else:
16451 
        iprot.skip(ftype)
16452 
      iprot.readFieldEnd()
16453 
    iprot.readStructEnd()
16454 
 
16455 
  def write(self, oprot):
16456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16458 
      return
16459 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 16460 
    if self.ex is not None:
2690 chandransh 16461 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16462 
      self.ex.write(oprot)
16463 
      oprot.writeFieldEnd()
16464 
    oprot.writeFieldStop()
16465 
    oprot.writeStructEnd()
16466 
 
3431 rajveer 16467 
  def validate(self):
16468 
    return
16469 
 
16470 
 
2690 chandransh 16471 
  def __repr__(self):
16472 
    L = ['%s=%r' % (key, value)
16473 
      for key, value in self.__dict__.iteritems()]
16474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16475 
 
16476 
  def __eq__(self, other):
16477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16478 
 
16479 
  def __ne__(self, other):
16480 
    return not (self == other)
16481 
 
3451 chandransh 16482 
class updateWeight_args:
16483 
  """
16484 
  Attributes:
16485 
   - orderId
16486 
   - weight
16487 
  """
16488 
 
16489 
  thrift_spec = (
16490 
    None, # 0
16491 
    (1, TType.I64, 'orderId', None, None, ), # 1
16492 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
16493 
  )
16494 
 
16495 
  def __init__(self, orderId=None, weight=None,):
16496 
    self.orderId = orderId
16497 
    self.weight = weight
16498 
 
16499 
  def read(self, iprot):
16500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16502 
      return
16503 
    iprot.readStructBegin()
16504 
    while True:
16505 
      (fname, ftype, fid) = iprot.readFieldBegin()
16506 
      if ftype == TType.STOP:
16507 
        break
16508 
      if fid == 1:
16509 
        if ftype == TType.I64:
16510 
          self.orderId = iprot.readI64();
16511 
        else:
16512 
          iprot.skip(ftype)
16513 
      elif fid == 2:
16514 
        if ftype == TType.DOUBLE:
16515 
          self.weight = iprot.readDouble();
16516 
        else:
16517 
          iprot.skip(ftype)
16518 
      else:
16519 
        iprot.skip(ftype)
16520 
      iprot.readFieldEnd()
16521 
    iprot.readStructEnd()
16522 
 
16523 
  def write(self, oprot):
16524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16526 
      return
16527 
    oprot.writeStructBegin('updateWeight_args')
16528 
    if self.orderId is not None:
16529 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16530 
      oprot.writeI64(self.orderId)
16531 
      oprot.writeFieldEnd()
16532 
    if self.weight is not None:
16533 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
16534 
      oprot.writeDouble(self.weight)
16535 
      oprot.writeFieldEnd()
16536 
    oprot.writeFieldStop()
16537 
    oprot.writeStructEnd()
16538 
 
16539 
  def validate(self):
16540 
    return
16541 
 
16542 
 
16543 
  def __repr__(self):
16544 
    L = ['%s=%r' % (key, value)
16545 
      for key, value in self.__dict__.iteritems()]
16546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16547 
 
16548 
  def __eq__(self, other):
16549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16550 
 
16551 
  def __ne__(self, other):
16552 
    return not (self == other)
16553 
 
16554 
class updateWeight_result:
16555 
  """
16556 
  Attributes:
16557 
   - success
16558 
   - ex
16559 
  """
16560 
 
16561 
  thrift_spec = (
16562 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16563 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16564 
  )
16565 
 
16566 
  def __init__(self, success=None, ex=None,):
16567 
    self.success = success
16568 
    self.ex = ex
16569 
 
16570 
  def read(self, iprot):
16571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16573 
      return
16574 
    iprot.readStructBegin()
16575 
    while True:
16576 
      (fname, ftype, fid) = iprot.readFieldBegin()
16577 
      if ftype == TType.STOP:
16578 
        break
16579 
      if fid == 0:
16580 
        if ftype == TType.STRUCT:
16581 
          self.success = Order()
16582 
          self.success.read(iprot)
16583 
        else:
16584 
          iprot.skip(ftype)
16585 
      elif fid == 1:
16586 
        if ftype == TType.STRUCT:
16587 
          self.ex = TransactionServiceException()
16588 
          self.ex.read(iprot)
16589 
        else:
16590 
          iprot.skip(ftype)
16591 
      else:
16592 
        iprot.skip(ftype)
16593 
      iprot.readFieldEnd()
16594 
    iprot.readStructEnd()
16595 
 
16596 
  def write(self, oprot):
16597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16599 
      return
16600 
    oprot.writeStructBegin('updateWeight_result')
16601 
    if self.success is not None:
16602 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16603 
      self.success.write(oprot)
16604 
      oprot.writeFieldEnd()
16605 
    if self.ex is not None:
16606 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16607 
      self.ex.write(oprot)
16608 
      oprot.writeFieldEnd()
16609 
    oprot.writeFieldStop()
16610 
    oprot.writeStructEnd()
16611 
 
16612 
  def validate(self):
16613 
    return
16614 
 
16615 
 
16616 
  def __repr__(self):
16617 
    L = ['%s=%r' % (key, value)
16618 
      for key, value in self.__dict__.iteritems()]
16619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16620 
 
16621 
  def __eq__(self, other):
16622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16623 
 
16624 
  def __ne__(self, other):
16625 
    return not (self == other)
3469 chandransh 16626 
 
16627 
class changeItem_args:
16628 
  """
16629 
  Attributes:
16630 
   - orderId
16631 
   - itemId
16632 
  """
16633 
 
16634 
  thrift_spec = (
16635 
    None, # 0
16636 
    (1, TType.I64, 'orderId', None, None, ), # 1
16637 
    (2, TType.I64, 'itemId', None, None, ), # 2
16638 
  )
16639 
 
16640 
  def __init__(self, orderId=None, itemId=None,):
16641 
    self.orderId = orderId
16642 
    self.itemId = itemId
16643 
 
16644 
  def read(self, iprot):
16645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16647 
      return
16648 
    iprot.readStructBegin()
16649 
    while True:
16650 
      (fname, ftype, fid) = iprot.readFieldBegin()
16651 
      if ftype == TType.STOP:
16652 
        break
16653 
      if fid == 1:
16654 
        if ftype == TType.I64:
16655 
          self.orderId = iprot.readI64();
16656 
        else:
16657 
          iprot.skip(ftype)
16658 
      elif fid == 2:
16659 
        if ftype == TType.I64:
16660 
          self.itemId = iprot.readI64();
16661 
        else:
16662 
          iprot.skip(ftype)
16663 
      else:
16664 
        iprot.skip(ftype)
16665 
      iprot.readFieldEnd()
16666 
    iprot.readStructEnd()
16667 
 
16668 
  def write(self, oprot):
16669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16671 
      return
16672 
    oprot.writeStructBegin('changeItem_args')
16673 
    if self.orderId is not None:
16674 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16675 
      oprot.writeI64(self.orderId)
16676 
      oprot.writeFieldEnd()
16677 
    if self.itemId is not None:
16678 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16679 
      oprot.writeI64(self.itemId)
16680 
      oprot.writeFieldEnd()
16681 
    oprot.writeFieldStop()
16682 
    oprot.writeStructEnd()
16683 
 
16684 
  def validate(self):
16685 
    return
16686 
 
16687 
 
16688 
  def __repr__(self):
16689 
    L = ['%s=%r' % (key, value)
16690 
      for key, value in self.__dict__.iteritems()]
16691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16692 
 
16693 
  def __eq__(self, other):
16694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16695 
 
16696 
  def __ne__(self, other):
16697 
    return not (self == other)
16698 
 
16699 
class changeItem_result:
16700 
  """
16701 
  Attributes:
16702 
   - success
16703 
   - ex
16704 
  """
16705 
 
16706 
  thrift_spec = (
16707 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16708 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16709 
  )
16710 
 
16711 
  def __init__(self, success=None, ex=None,):
16712 
    self.success = success
16713 
    self.ex = ex
16714 
 
16715 
  def read(self, iprot):
16716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16718 
      return
16719 
    iprot.readStructBegin()
16720 
    while True:
16721 
      (fname, ftype, fid) = iprot.readFieldBegin()
16722 
      if ftype == TType.STOP:
16723 
        break
16724 
      if fid == 0:
16725 
        if ftype == TType.STRUCT:
16726 
          self.success = Order()
16727 
          self.success.read(iprot)
16728 
        else:
16729 
          iprot.skip(ftype)
16730 
      elif fid == 1:
16731 
        if ftype == TType.STRUCT:
16732 
          self.ex = TransactionServiceException()
16733 
          self.ex.read(iprot)
16734 
        else:
16735 
          iprot.skip(ftype)
16736 
      else:
16737 
        iprot.skip(ftype)
16738 
      iprot.readFieldEnd()
16739 
    iprot.readStructEnd()
16740 
 
16741 
  def write(self, oprot):
16742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16744 
      return
16745 
    oprot.writeStructBegin('changeItem_result')
16746 
    if self.success is not None:
16747 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16748 
      self.success.write(oprot)
16749 
      oprot.writeFieldEnd()
16750 
    if self.ex is not None:
16751 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16752 
      self.ex.write(oprot)
16753 
      oprot.writeFieldEnd()
16754 
    oprot.writeFieldStop()
16755 
    oprot.writeStructEnd()
16756 
 
16757 
  def validate(self):
16758 
    return
16759 
 
16760 
 
16761 
  def __repr__(self):
16762 
    L = ['%s=%r' % (key, value)
16763 
      for key, value in self.__dict__.iteritems()]
16764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16765 
 
16766 
  def __eq__(self, other):
16767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16768 
 
16769 
  def __ne__(self, other):
16770 
    return not (self == other)
16771 
 
16772 
class shiftToWarehouse_args:
16773 
  """
16774 
  Attributes:
16775 
   - orderId
16776 
   - warehouseId
16777 
  """
16778 
 
16779 
  thrift_spec = (
16780 
    None, # 0
16781 
    (1, TType.I64, 'orderId', None, None, ), # 1
16782 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
16783 
  )
16784 
 
16785 
  def __init__(self, orderId=None, warehouseId=None,):
16786 
    self.orderId = orderId
16787 
    self.warehouseId = warehouseId
16788 
 
16789 
  def read(self, iprot):
16790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16792 
      return
16793 
    iprot.readStructBegin()
16794 
    while True:
16795 
      (fname, ftype, fid) = iprot.readFieldBegin()
16796 
      if ftype == TType.STOP:
16797 
        break
16798 
      if fid == 1:
16799 
        if ftype == TType.I64:
16800 
          self.orderId = iprot.readI64();
16801 
        else:
16802 
          iprot.skip(ftype)
16803 
      elif fid == 2:
16804 
        if ftype == TType.I64:
16805 
          self.warehouseId = iprot.readI64();
16806 
        else:
16807 
          iprot.skip(ftype)
16808 
      else:
16809 
        iprot.skip(ftype)
16810 
      iprot.readFieldEnd()
16811 
    iprot.readStructEnd()
16812 
 
16813 
  def write(self, oprot):
16814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16816 
      return
16817 
    oprot.writeStructBegin('shiftToWarehouse_args')
16818 
    if self.orderId is not None:
16819 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16820 
      oprot.writeI64(self.orderId)
16821 
      oprot.writeFieldEnd()
16822 
    if self.warehouseId is not None:
16823 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16824 
      oprot.writeI64(self.warehouseId)
16825 
      oprot.writeFieldEnd()
16826 
    oprot.writeFieldStop()
16827 
    oprot.writeStructEnd()
16828 
 
16829 
  def validate(self):
16830 
    return
16831 
 
16832 
 
16833 
  def __repr__(self):
16834 
    L = ['%s=%r' % (key, value)
16835 
      for key, value in self.__dict__.iteritems()]
16836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16837 
 
16838 
  def __eq__(self, other):
16839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16840 
 
16841 
  def __ne__(self, other):
16842 
    return not (self == other)
16843 
 
16844 
class shiftToWarehouse_result:
16845 
  """
16846 
  Attributes:
16847 
   - success
16848 
   - ex
16849 
  """
16850 
 
16851 
  thrift_spec = (
16852 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16853 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16854 
  )
16855 
 
16856 
  def __init__(self, success=None, ex=None,):
16857 
    self.success = success
16858 
    self.ex = ex
16859 
 
16860 
  def read(self, iprot):
16861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16863 
      return
16864 
    iprot.readStructBegin()
16865 
    while True:
16866 
      (fname, ftype, fid) = iprot.readFieldBegin()
16867 
      if ftype == TType.STOP:
16868 
        break
16869 
      if fid == 0:
16870 
        if ftype == TType.STRUCT:
16871 
          self.success = Order()
16872 
          self.success.read(iprot)
16873 
        else:
16874 
          iprot.skip(ftype)
16875 
      elif fid == 1:
16876 
        if ftype == TType.STRUCT:
16877 
          self.ex = TransactionServiceException()
16878 
          self.ex.read(iprot)
16879 
        else:
16880 
          iprot.skip(ftype)
16881 
      else:
16882 
        iprot.skip(ftype)
16883 
      iprot.readFieldEnd()
16884 
    iprot.readStructEnd()
16885 
 
16886 
  def write(self, oprot):
16887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16889 
      return
16890 
    oprot.writeStructBegin('shiftToWarehouse_result')
16891 
    if self.success is not None:
16892 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16893 
      self.success.write(oprot)
16894 
      oprot.writeFieldEnd()
16895 
    if self.ex is not None:
16896 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16897 
      self.ex.write(oprot)
16898 
      oprot.writeFieldEnd()
16899 
    oprot.writeFieldStop()
16900 
    oprot.writeStructEnd()
16901 
 
16902 
  def validate(self):
16903 
    return
16904 
 
16905 
 
16906 
  def __repr__(self):
16907 
    L = ['%s=%r' % (key, value)
16908 
      for key, value in self.__dict__.iteritems()]
16909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16910 
 
16911 
  def __eq__(self, other):
16912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16913 
 
16914 
  def __ne__(self, other):
16915 
    return not (self == other)
3553 chandransh 16916 
 
16917 
class addDelayReason_args:
16918 
  """
16919 
  Attributes:
16920 
   - orderId
16921 
   - delayReason
3986 chandransh 16922 
   - furtherDelay
4647 rajveer 16923 
   - delayReasonText
3553 chandransh 16924 
  """
16925 
 
16926 
  thrift_spec = (
16927 
    None, # 0
16928 
    (1, TType.I64, 'orderId', None, None, ), # 1
16929 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 16930 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 16931 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 16932 
  )
16933 
 
4647 rajveer 16934 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 16935 
    self.orderId = orderId
16936 
    self.delayReason = delayReason
3986 chandransh 16937 
    self.furtherDelay = furtherDelay
4647 rajveer 16938 
    self.delayReasonText = delayReasonText
3553 chandransh 16939 
 
16940 
  def read(self, iprot):
16941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16943 
      return
16944 
    iprot.readStructBegin()
16945 
    while True:
16946 
      (fname, ftype, fid) = iprot.readFieldBegin()
16947 
      if ftype == TType.STOP:
16948 
        break
16949 
      if fid == 1:
16950 
        if ftype == TType.I64:
16951 
          self.orderId = iprot.readI64();
16952 
        else:
16953 
          iprot.skip(ftype)
16954 
      elif fid == 2:
16955 
        if ftype == TType.I32:
16956 
          self.delayReason = iprot.readI32();
16957 
        else:
16958 
          iprot.skip(ftype)
3986 chandransh 16959 
      elif fid == 3:
16960 
        if ftype == TType.I64:
16961 
          self.furtherDelay = iprot.readI64();
16962 
        else:
16963 
          iprot.skip(ftype)
4647 rajveer 16964 
      elif fid == 4:
16965 
        if ftype == TType.STRING:
16966 
          self.delayReasonText = iprot.readString();
16967 
        else:
16968 
          iprot.skip(ftype)
3553 chandransh 16969 
      else:
16970 
        iprot.skip(ftype)
16971 
      iprot.readFieldEnd()
16972 
    iprot.readStructEnd()
16973 
 
16974 
  def write(self, oprot):
16975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16977 
      return
16978 
    oprot.writeStructBegin('addDelayReason_args')
16979 
    if self.orderId is not None:
16980 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16981 
      oprot.writeI64(self.orderId)
16982 
      oprot.writeFieldEnd()
16983 
    if self.delayReason is not None:
16984 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
16985 
      oprot.writeI32(self.delayReason)
16986 
      oprot.writeFieldEnd()
3986 chandransh 16987 
    if self.furtherDelay is not None:
16988 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
16989 
      oprot.writeI64(self.furtherDelay)
16990 
      oprot.writeFieldEnd()
4647 rajveer 16991 
    if self.delayReasonText is not None:
16992 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
16993 
      oprot.writeString(self.delayReasonText)
16994 
      oprot.writeFieldEnd()
3553 chandransh 16995 
    oprot.writeFieldStop()
16996 
    oprot.writeStructEnd()
16997 
 
16998 
  def validate(self):
16999 
    return
17000 
 
17001 
 
17002 
  def __repr__(self):
17003 
    L = ['%s=%r' % (key, value)
17004 
      for key, value in self.__dict__.iteritems()]
17005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17006 
 
17007 
  def __eq__(self, other):
17008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17009 
 
17010 
  def __ne__(self, other):
17011 
    return not (self == other)
17012 
 
17013 
class addDelayReason_result:
17014 
  """
17015 
  Attributes:
17016 
   - success
17017 
   - ex
17018 
  """
17019 
 
17020 
  thrift_spec = (
17021 
    (0, TType.BOOL, 'success', None, None, ), # 0
17022 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17023 
  )
17024 
 
17025 
  def __init__(self, success=None, ex=None,):
17026 
    self.success = success
17027 
    self.ex = ex
17028 
 
17029 
  def read(self, iprot):
17030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17032 
      return
17033 
    iprot.readStructBegin()
17034 
    while True:
17035 
      (fname, ftype, fid) = iprot.readFieldBegin()
17036 
      if ftype == TType.STOP:
17037 
        break
17038 
      if fid == 0:
17039 
        if ftype == TType.BOOL:
17040 
          self.success = iprot.readBool();
17041 
        else:
17042 
          iprot.skip(ftype)
17043 
      elif fid == 1:
17044 
        if ftype == TType.STRUCT:
17045 
          self.ex = TransactionServiceException()
17046 
          self.ex.read(iprot)
17047 
        else:
17048 
          iprot.skip(ftype)
17049 
      else:
17050 
        iprot.skip(ftype)
17051 
      iprot.readFieldEnd()
17052 
    iprot.readStructEnd()
17053 
 
17054 
  def write(self, oprot):
17055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17057 
      return
17058 
    oprot.writeStructBegin('addDelayReason_result')
17059 
    if self.success is not None:
17060 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17061 
      oprot.writeBool(self.success)
17062 
      oprot.writeFieldEnd()
17063 
    if self.ex is not None:
17064 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17065 
      self.ex.write(oprot)
17066 
      oprot.writeFieldEnd()
17067 
    oprot.writeFieldStop()
17068 
    oprot.writeStructEnd()
17069 
 
17070 
  def validate(self):
17071 
    return
17072 
 
17073 
 
17074 
  def __repr__(self):
17075 
    L = ['%s=%r' % (key, value)
17076 
      for key, value in self.__dict__.iteritems()]
17077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17078 
 
17079 
  def __eq__(self, other):
17080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17081 
 
17082 
  def __ne__(self, other):
17083 
    return not (self == other)
3956 chandransh 17084 
 
17085 
class reconcileCodCollection_args:
17086 
  """
17087 
  Attributes:
17088 
   - collectedAmountMap
17089 
   - xferBy
17090 
   - xferTxnId
17091 
   - xferDate
17092 
  """
17093 
 
17094 
  thrift_spec = (
17095 
    None, # 0
17096 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
17097 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
17098 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
17099 
    (4, TType.I64, 'xferDate', None, None, ), # 4
17100 
  )
17101 
 
17102 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
17103 
    self.collectedAmountMap = collectedAmountMap
17104 
    self.xferBy = xferBy
17105 
    self.xferTxnId = xferTxnId
17106 
    self.xferDate = xferDate
17107 
 
17108 
  def read(self, iprot):
17109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17111 
      return
17112 
    iprot.readStructBegin()
17113 
    while True:
17114 
      (fname, ftype, fid) = iprot.readFieldBegin()
17115 
      if ftype == TType.STOP:
17116 
        break
17117 
      if fid == 1:
17118 
        if ftype == TType.MAP:
17119 
          self.collectedAmountMap = {}
5031 varun.gupt 17120 
          (_ktype362, _vtype363, _size361 ) = iprot.readMapBegin()
17121 
          for _i365 in xrange(_size361):
17122 
            _key366 = iprot.readString();
17123 
            _val367 = iprot.readDouble();
17124 
            self.collectedAmountMap[_key366] = _val367
3956 chandransh 17125 
          iprot.readMapEnd()
17126 
        else:
17127 
          iprot.skip(ftype)
17128 
      elif fid == 2:
17129 
        if ftype == TType.STRING:
17130 
          self.xferBy = iprot.readString();
17131 
        else:
17132 
          iprot.skip(ftype)
17133 
      elif fid == 3:
17134 
        if ftype == TType.STRING:
17135 
          self.xferTxnId = iprot.readString();
17136 
        else:
17137 
          iprot.skip(ftype)
17138 
      elif fid == 4:
17139 
        if ftype == TType.I64:
17140 
          self.xferDate = iprot.readI64();
17141 
        else:
17142 
          iprot.skip(ftype)
17143 
      else:
17144 
        iprot.skip(ftype)
17145 
      iprot.readFieldEnd()
17146 
    iprot.readStructEnd()
17147 
 
17148 
  def write(self, oprot):
17149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17151 
      return
17152 
    oprot.writeStructBegin('reconcileCodCollection_args')
17153 
    if self.collectedAmountMap is not None:
17154 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
17155 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
5031 varun.gupt 17156 
      for kiter368,viter369 in self.collectedAmountMap.items():
17157 
        oprot.writeString(kiter368)
17158 
        oprot.writeDouble(viter369)
3956 chandransh 17159 
      oprot.writeMapEnd()
17160 
      oprot.writeFieldEnd()
17161 
    if self.xferBy is not None:
17162 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
17163 
      oprot.writeString(self.xferBy)
17164 
      oprot.writeFieldEnd()
17165 
    if self.xferTxnId is not None:
17166 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
17167 
      oprot.writeString(self.xferTxnId)
17168 
      oprot.writeFieldEnd()
17169 
    if self.xferDate is not None:
17170 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
17171 
      oprot.writeI64(self.xferDate)
17172 
      oprot.writeFieldEnd()
17173 
    oprot.writeFieldStop()
17174 
    oprot.writeStructEnd()
17175 
 
17176 
  def validate(self):
17177 
    return
17178 
 
17179 
 
17180 
  def __repr__(self):
17181 
    L = ['%s=%r' % (key, value)
17182 
      for key, value in self.__dict__.iteritems()]
17183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17184 
 
17185 
  def __eq__(self, other):
17186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17187 
 
17188 
  def __ne__(self, other):
17189 
    return not (self == other)
17190 
 
17191 
class reconcileCodCollection_result:
17192 
  """
17193 
  Attributes:
17194 
   - success
17195 
   - ex
17196 
  """
17197 
 
17198 
  thrift_spec = (
17199 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
17200 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17201 
  )
17202 
 
17203 
  def __init__(self, success=None, ex=None,):
17204 
    self.success = success
17205 
    self.ex = ex
17206 
 
17207 
  def read(self, iprot):
17208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17210 
      return
17211 
    iprot.readStructBegin()
17212 
    while True:
17213 
      (fname, ftype, fid) = iprot.readFieldBegin()
17214 
      if ftype == TType.STOP:
17215 
        break
17216 
      if fid == 0:
17217 
        if ftype == TType.MAP:
17218 
          self.success = {}
5031 varun.gupt 17219 
          (_ktype371, _vtype372, _size370 ) = iprot.readMapBegin()
17220 
          for _i374 in xrange(_size370):
17221 
            _key375 = iprot.readString();
17222 
            _val376 = iprot.readString();
17223 
            self.success[_key375] = _val376
3956 chandransh 17224 
          iprot.readMapEnd()
17225 
        else:
17226 
          iprot.skip(ftype)
17227 
      elif fid == 1:
17228 
        if ftype == TType.STRUCT:
17229 
          self.ex = TransactionServiceException()
17230 
          self.ex.read(iprot)
17231 
        else:
17232 
          iprot.skip(ftype)
17233 
      else:
17234 
        iprot.skip(ftype)
17235 
      iprot.readFieldEnd()
17236 
    iprot.readStructEnd()
17237 
 
17238 
  def write(self, oprot):
17239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17241 
      return
17242 
    oprot.writeStructBegin('reconcileCodCollection_result')
17243 
    if self.success is not None:
17244 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17245 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
5031 varun.gupt 17246 
      for kiter377,viter378 in self.success.items():
17247 
        oprot.writeString(kiter377)
17248 
        oprot.writeString(viter378)
3956 chandransh 17249 
      oprot.writeMapEnd()
17250 
      oprot.writeFieldEnd()
17251 
    if self.ex is not None:
17252 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17253 
      self.ex.write(oprot)
17254 
      oprot.writeFieldEnd()
17255 
    oprot.writeFieldStop()
17256 
    oprot.writeStructEnd()
17257 
 
17258 
  def validate(self):
17259 
    return
17260 
 
17261 
 
17262 
  def __repr__(self):
17263 
    L = ['%s=%r' % (key, value)
17264 
      for key, value in self.__dict__.iteritems()]
17265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17266 
 
17267 
  def __eq__(self, other):
17268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17269 
 
17270 
  def __ne__(self, other):
17271 
    return not (self == other)
4008 mandeep.dh 17272 
 
17273 
class getTransactionsRequiringExtraProcessing_args:
17274 
  """
17275 
  Attributes:
17276 
   - category
17277 
  """
17278 
 
17279 
  thrift_spec = (
17280 
    None, # 0
17281 
    (1, TType.I32, 'category', None, None, ), # 1
17282 
  )
17283 
 
17284 
  def __init__(self, category=None,):
17285 
    self.category = category
17286 
 
17287 
  def read(self, iprot):
17288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17290 
      return
17291 
    iprot.readStructBegin()
17292 
    while True:
17293 
      (fname, ftype, fid) = iprot.readFieldBegin()
17294 
      if ftype == TType.STOP:
17295 
        break
17296 
      if fid == 1:
17297 
        if ftype == TType.I32:
17298 
          self.category = iprot.readI32();
17299 
        else:
17300 
          iprot.skip(ftype)
17301 
      else:
17302 
        iprot.skip(ftype)
17303 
      iprot.readFieldEnd()
17304 
    iprot.readStructEnd()
17305 
 
17306 
  def write(self, oprot):
17307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17309 
      return
17310 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
17311 
    if self.category is not None:
17312 
      oprot.writeFieldBegin('category', TType.I32, 1)
17313 
      oprot.writeI32(self.category)
17314 
      oprot.writeFieldEnd()
17315 
    oprot.writeFieldStop()
17316 
    oprot.writeStructEnd()
17317 
 
17318 
  def validate(self):
17319 
    return
17320 
 
17321 
 
17322 
  def __repr__(self):
17323 
    L = ['%s=%r' % (key, value)
17324 
      for key, value in self.__dict__.iteritems()]
17325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17326 
 
17327 
  def __eq__(self, other):
17328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17329 
 
17330 
  def __ne__(self, other):
17331 
    return not (self == other)
17332 
 
17333 
class getTransactionsRequiringExtraProcessing_result:
17334 
  """
17335 
  Attributes:
17336 
   - success
17337 
  """
17338 
 
17339 
  thrift_spec = (
17340 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
17341 
  )
17342 
 
17343 
  def __init__(self, success=None,):
17344 
    self.success = success
17345 
 
17346 
  def read(self, iprot):
17347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17349 
      return
17350 
    iprot.readStructBegin()
17351 
    while True:
17352 
      (fname, ftype, fid) = iprot.readFieldBegin()
17353 
      if ftype == TType.STOP:
17354 
        break
17355 
      if fid == 0:
17356 
        if ftype == TType.LIST:
17357 
          self.success = []
5031 varun.gupt 17358 
          (_etype382, _size379) = iprot.readListBegin()
17359 
          for _i383 in xrange(_size379):
17360 
            _elem384 = iprot.readI64();
17361 
            self.success.append(_elem384)
4008 mandeep.dh 17362 
          iprot.readListEnd()
17363 
        else:
17364 
          iprot.skip(ftype)
17365 
      else:
17366 
        iprot.skip(ftype)
17367 
      iprot.readFieldEnd()
17368 
    iprot.readStructEnd()
17369 
 
17370 
  def write(self, oprot):
17371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17373 
      return
17374 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
17375 
    if self.success is not None:
17376 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17377 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 17378 
      for iter385 in self.success:
17379 
        oprot.writeI64(iter385)
4008 mandeep.dh 17380 
      oprot.writeListEnd()
17381 
      oprot.writeFieldEnd()
17382 
    oprot.writeFieldStop()
17383 
    oprot.writeStructEnd()
17384 
 
17385 
  def validate(self):
17386 
    return
17387 
 
17388 
 
17389 
  def __repr__(self):
17390 
    L = ['%s=%r' % (key, value)
17391 
      for key, value in self.__dict__.iteritems()]
17392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17393 
 
17394 
  def __eq__(self, other):
17395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17396 
 
17397 
  def __ne__(self, other):
17398 
    return not (self == other)
17399 
 
17400 
class markTransactionAsProcessed_args:
17401 
  """
17402 
  Attributes:
17403 
   - transactionId
17404 
   - category
17405 
  """
17406 
 
17407 
  thrift_spec = (
17408 
    None, # 0
17409 
    (1, TType.I64, 'transactionId', None, None, ), # 1
17410 
    (2, TType.I32, 'category', None, None, ), # 2
17411 
  )
17412 
 
17413 
  def __init__(self, transactionId=None, category=None,):
17414 
    self.transactionId = transactionId
17415 
    self.category = category
17416 
 
17417 
  def read(self, iprot):
17418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17420 
      return
17421 
    iprot.readStructBegin()
17422 
    while True:
17423 
      (fname, ftype, fid) = iprot.readFieldBegin()
17424 
      if ftype == TType.STOP:
17425 
        break
17426 
      if fid == 1:
17427 
        if ftype == TType.I64:
17428 
          self.transactionId = iprot.readI64();
17429 
        else:
17430 
          iprot.skip(ftype)
17431 
      elif fid == 2:
17432 
        if ftype == TType.I32:
17433 
          self.category = iprot.readI32();
17434 
        else:
17435 
          iprot.skip(ftype)
17436 
      else:
17437 
        iprot.skip(ftype)
17438 
      iprot.readFieldEnd()
17439 
    iprot.readStructEnd()
17440 
 
17441 
  def write(self, oprot):
17442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17444 
      return
17445 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
17446 
    if self.transactionId is not None:
17447 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
17448 
      oprot.writeI64(self.transactionId)
17449 
      oprot.writeFieldEnd()
17450 
    if self.category is not None:
17451 
      oprot.writeFieldBegin('category', TType.I32, 2)
17452 
      oprot.writeI32(self.category)
17453 
      oprot.writeFieldEnd()
17454 
    oprot.writeFieldStop()
17455 
    oprot.writeStructEnd()
17456 
 
17457 
  def validate(self):
17458 
    return
17459 
 
17460 
 
17461 
  def __repr__(self):
17462 
    L = ['%s=%r' % (key, value)
17463 
      for key, value in self.__dict__.iteritems()]
17464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17465 
 
17466 
  def __eq__(self, other):
17467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17468 
 
17469 
  def __ne__(self, other):
17470 
    return not (self == other)
17471 
 
17472 
class markTransactionAsProcessed_result:
17473 
 
17474 
  thrift_spec = (
17475 
  )
17476 
 
17477 
  def read(self, iprot):
17478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17480 
      return
17481 
    iprot.readStructBegin()
17482 
    while True:
17483 
      (fname, ftype, fid) = iprot.readFieldBegin()
17484 
      if ftype == TType.STOP:
17485 
        break
17486 
      else:
17487 
        iprot.skip(ftype)
17488 
      iprot.readFieldEnd()
17489 
    iprot.readStructEnd()
17490 
 
17491 
  def write(self, oprot):
17492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17494 
      return
17495 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
17496 
    oprot.writeFieldStop()
17497 
    oprot.writeStructEnd()
17498 
 
17499 
  def validate(self):
17500 
    return
17501 
 
17502 
 
17503 
  def __repr__(self):
17504 
    L = ['%s=%r' % (key, value)
17505 
      for key, value in self.__dict__.iteritems()]
17506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17507 
 
17508 
  def __eq__(self, other):
17509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17510 
 
17511 
  def __ne__(self, other):
17512 
    return not (self == other)
4018 chandransh 17513 
 
17514 
class getItemWiseRiskyOrdersCount_args:
17515 
 
17516 
  thrift_spec = (
17517 
  )
17518 
 
17519 
  def read(self, iprot):
17520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17522 
      return
17523 
    iprot.readStructBegin()
17524 
    while True:
17525 
      (fname, ftype, fid) = iprot.readFieldBegin()
17526 
      if ftype == TType.STOP:
17527 
        break
17528 
      else:
17529 
        iprot.skip(ftype)
17530 
      iprot.readFieldEnd()
17531 
    iprot.readStructEnd()
17532 
 
17533 
  def write(self, oprot):
17534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17536 
      return
17537 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
17538 
    oprot.writeFieldStop()
17539 
    oprot.writeStructEnd()
17540 
 
17541 
  def validate(self):
17542 
    return
17543 
 
17544 
 
17545 
  def __repr__(self):
17546 
    L = ['%s=%r' % (key, value)
17547 
      for key, value in self.__dict__.iteritems()]
17548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17549 
 
17550 
  def __eq__(self, other):
17551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17552 
 
17553 
  def __ne__(self, other):
17554 
    return not (self == other)
17555 
 
17556 
class getItemWiseRiskyOrdersCount_result:
17557 
  """
17558 
  Attributes:
17559 
   - success
17560 
  """
17561 
 
17562 
  thrift_spec = (
17563 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
17564 
  )
17565 
 
17566 
  def __init__(self, success=None,):
17567 
    self.success = success
17568 
 
17569 
  def read(self, iprot):
17570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17572 
      return
17573 
    iprot.readStructBegin()
17574 
    while True:
17575 
      (fname, ftype, fid) = iprot.readFieldBegin()
17576 
      if ftype == TType.STOP:
17577 
        break
17578 
      if fid == 0:
17579 
        if ftype == TType.MAP:
17580 
          self.success = {}
5031 varun.gupt 17581 
          (_ktype387, _vtype388, _size386 ) = iprot.readMapBegin()
17582 
          for _i390 in xrange(_size386):
17583 
            _key391 = iprot.readI64();
17584 
            _val392 = iprot.readI64();
17585 
            self.success[_key391] = _val392
4018 chandransh 17586 
          iprot.readMapEnd()
17587 
        else:
17588 
          iprot.skip(ftype)
17589 
      else:
17590 
        iprot.skip(ftype)
17591 
      iprot.readFieldEnd()
17592 
    iprot.readStructEnd()
17593 
 
17594 
  def write(self, oprot):
17595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17597 
      return
17598 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
17599 
    if self.success is not None:
17600 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17601 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5031 varun.gupt 17602 
      for kiter393,viter394 in self.success.items():
17603 
        oprot.writeI64(kiter393)
17604 
        oprot.writeI64(viter394)
4018 chandransh 17605 
      oprot.writeMapEnd()
17606 
      oprot.writeFieldEnd()
17607 
    oprot.writeFieldStop()
17608 
    oprot.writeStructEnd()
17609 
 
17610 
  def validate(self):
17611 
    return
17612 
 
17613 
 
17614 
  def __repr__(self):
17615 
    L = ['%s=%r' % (key, value)
17616 
      for key, value in self.__dict__.iteritems()]
17617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17618 
 
17619 
  def __eq__(self, other):
17620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17621 
 
17622 
  def __ne__(self, other):
17623 
    return not (self == other)
4247 rajveer 17624 
 
4295 varun.gupt 17625 
class getOrdersForItemIds_args:
17626 
  """
17627 
  Attributes:
17628 
   - itemIds
17629 
  """
17630 
 
17631 
  thrift_spec = (
17632 
    None, # 0
17633 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
17634 
  )
17635 
 
17636 
  def __init__(self, itemIds=None,):
17637 
    self.itemIds = itemIds
17638 
 
17639 
  def read(self, iprot):
17640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17642 
      return
17643 
    iprot.readStructBegin()
17644 
    while True:
17645 
      (fname, ftype, fid) = iprot.readFieldBegin()
17646 
      if ftype == TType.STOP:
17647 
        break
17648 
      if fid == 1:
17649 
        if ftype == TType.LIST:
17650 
          self.itemIds = []
5031 varun.gupt 17651 
          (_etype398, _size395) = iprot.readListBegin()
17652 
          for _i399 in xrange(_size395):
17653 
            _elem400 = iprot.readI64();
17654 
            self.itemIds.append(_elem400)
4295 varun.gupt 17655 
          iprot.readListEnd()
17656 
        else:
17657 
          iprot.skip(ftype)
17658 
      else:
17659 
        iprot.skip(ftype)
17660 
      iprot.readFieldEnd()
17661 
    iprot.readStructEnd()
17662 
 
17663 
  def write(self, oprot):
17664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17666 
      return
17667 
    oprot.writeStructBegin('getOrdersForItemIds_args')
17668 
    if self.itemIds is not None:
17669 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
17670 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5031 varun.gupt 17671 
      for iter401 in self.itemIds:
17672 
        oprot.writeI64(iter401)
4295 varun.gupt 17673 
      oprot.writeListEnd()
17674 
      oprot.writeFieldEnd()
17675 
    oprot.writeFieldStop()
17676 
    oprot.writeStructEnd()
17677 
 
17678 
  def validate(self):
17679 
    return
17680 
 
17681 
 
17682 
  def __repr__(self):
17683 
    L = ['%s=%r' % (key, value)
17684 
      for key, value in self.__dict__.iteritems()]
17685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17686 
 
17687 
  def __eq__(self, other):
17688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17689 
 
17690 
  def __ne__(self, other):
17691 
    return not (self == other)
17692 
 
17693 
class getOrdersForItemIds_result:
17694 
  """
17695 
  Attributes:
17696 
   - success
17697 
  """
17698 
 
17699 
  thrift_spec = (
17700 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17701 
  )
17702 
 
17703 
  def __init__(self, success=None,):
17704 
    self.success = success
17705 
 
17706 
  def read(self, iprot):
17707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17709 
      return
17710 
    iprot.readStructBegin()
17711 
    while True:
17712 
      (fname, ftype, fid) = iprot.readFieldBegin()
17713 
      if ftype == TType.STOP:
17714 
        break
17715 
      if fid == 0:
17716 
        if ftype == TType.LIST:
17717 
          self.success = []
5031 varun.gupt 17718 
          (_etype405, _size402) = iprot.readListBegin()
17719 
          for _i406 in xrange(_size402):
17720 
            _elem407 = Order()
17721 
            _elem407.read(iprot)
17722 
            self.success.append(_elem407)
4295 varun.gupt 17723 
          iprot.readListEnd()
17724 
        else:
17725 
          iprot.skip(ftype)
17726 
      else:
17727 
        iprot.skip(ftype)
17728 
      iprot.readFieldEnd()
17729 
    iprot.readStructEnd()
17730 
 
17731 
  def write(self, oprot):
17732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17734 
      return
17735 
    oprot.writeStructBegin('getOrdersForItemIds_result')
17736 
    if self.success is not None:
17737 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17738 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 17739 
      for iter408 in self.success:
17740 
        iter408.write(oprot)
4295 varun.gupt 17741 
      oprot.writeListEnd()
17742 
      oprot.writeFieldEnd()
17743 
    oprot.writeFieldStop()
17744 
    oprot.writeStructEnd()
17745 
 
17746 
  def validate(self):
17747 
    return
17748 
 
17749 
 
17750 
  def __repr__(self):
17751 
    L = ['%s=%r' % (key, value)
17752 
      for key, value in self.__dict__.iteritems()]
17753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17754 
 
17755 
  def __eq__(self, other):
17756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17757 
 
17758 
  def __ne__(self, other):
17759 
    return not (self == other)
17760 
 
4247 rajveer 17761 
class markOrderCancellationRequestReceived_args:
17762 
  """
17763 
  Attributes:
17764 
   - orderId
17765 
  """
17766 
 
17767 
  thrift_spec = (
17768 
    None, # 0
17769 
    (1, TType.I64, 'orderId', None, None, ), # 1
17770 
  )
17771 
 
17772 
  def __init__(self, orderId=None,):
17773 
    self.orderId = orderId
17774 
 
17775 
  def read(self, iprot):
17776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17778 
      return
17779 
    iprot.readStructBegin()
17780 
    while True:
17781 
      (fname, ftype, fid) = iprot.readFieldBegin()
17782 
      if ftype == TType.STOP:
17783 
        break
17784 
      if fid == 1:
17785 
        if ftype == TType.I64:
17786 
          self.orderId = iprot.readI64();
17787 
        else:
17788 
          iprot.skip(ftype)
17789 
      else:
17790 
        iprot.skip(ftype)
17791 
      iprot.readFieldEnd()
17792 
    iprot.readStructEnd()
17793 
 
17794 
  def write(self, oprot):
17795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17797 
      return
17798 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
17799 
    if self.orderId is not None:
17800 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17801 
      oprot.writeI64(self.orderId)
17802 
      oprot.writeFieldEnd()
17803 
    oprot.writeFieldStop()
17804 
    oprot.writeStructEnd()
17805 
 
17806 
  def validate(self):
17807 
    return
17808 
 
17809 
 
17810 
  def __repr__(self):
17811 
    L = ['%s=%r' % (key, value)
17812 
      for key, value in self.__dict__.iteritems()]
17813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17814 
 
17815 
  def __eq__(self, other):
17816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17817 
 
17818 
  def __ne__(self, other):
17819 
    return not (self == other)
17820 
 
17821 
class markOrderCancellationRequestReceived_result:
17822 
  """
17823 
  Attributes:
17824 
   - ex
17825 
  """
17826 
 
17827 
  thrift_spec = (
17828 
    None, # 0
17829 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17830 
  )
17831 
 
17832 
  def __init__(self, ex=None,):
17833 
    self.ex = ex
17834 
 
17835 
  def read(self, iprot):
17836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17838 
      return
17839 
    iprot.readStructBegin()
17840 
    while True:
17841 
      (fname, ftype, fid) = iprot.readFieldBegin()
17842 
      if ftype == TType.STOP:
17843 
        break
17844 
      if fid == 1:
17845 
        if ftype == TType.STRUCT:
17846 
          self.ex = TransactionServiceException()
17847 
          self.ex.read(iprot)
17848 
        else:
17849 
          iprot.skip(ftype)
17850 
      else:
17851 
        iprot.skip(ftype)
17852 
      iprot.readFieldEnd()
17853 
    iprot.readStructEnd()
17854 
 
17855 
  def write(self, oprot):
17856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17858 
      return
17859 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
17860 
    if self.ex is not None:
17861 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17862 
      self.ex.write(oprot)
17863 
      oprot.writeFieldEnd()
17864 
    oprot.writeFieldStop()
17865 
    oprot.writeStructEnd()
17866 
 
17867 
  def validate(self):
17868 
    return
17869 
 
17870 
 
17871 
  def __repr__(self):
17872 
    L = ['%s=%r' % (key, value)
17873 
      for key, value in self.__dict__.iteritems()]
17874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17875 
 
17876 
  def __eq__(self, other):
17877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17878 
 
17879 
  def __ne__(self, other):
17880 
    return not (self == other)
17881 
 
17882 
class markOrderCancellationRequestConfirmed_args:
17883 
  """
17884 
  Attributes:
17885 
   - orderId
17886 
  """
17887 
 
17888 
  thrift_spec = (
17889 
    None, # 0
17890 
    (1, TType.I64, 'orderId', None, None, ), # 1
17891 
  )
17892 
 
17893 
  def __init__(self, orderId=None,):
17894 
    self.orderId = orderId
17895 
 
17896 
  def read(self, iprot):
17897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17899 
      return
17900 
    iprot.readStructBegin()
17901 
    while True:
17902 
      (fname, ftype, fid) = iprot.readFieldBegin()
17903 
      if ftype == TType.STOP:
17904 
        break
17905 
      if fid == 1:
17906 
        if ftype == TType.I64:
17907 
          self.orderId = iprot.readI64();
17908 
        else:
17909 
          iprot.skip(ftype)
17910 
      else:
17911 
        iprot.skip(ftype)
17912 
      iprot.readFieldEnd()
17913 
    iprot.readStructEnd()
17914 
 
17915 
  def write(self, oprot):
17916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17918 
      return
17919 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
17920 
    if self.orderId is not None:
17921 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17922 
      oprot.writeI64(self.orderId)
17923 
      oprot.writeFieldEnd()
17924 
    oprot.writeFieldStop()
17925 
    oprot.writeStructEnd()
17926 
 
17927 
  def validate(self):
17928 
    return
17929 
 
17930 
 
17931 
  def __repr__(self):
17932 
    L = ['%s=%r' % (key, value)
17933 
      for key, value in self.__dict__.iteritems()]
17934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17935 
 
17936 
  def __eq__(self, other):
17937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17938 
 
17939 
  def __ne__(self, other):
17940 
    return not (self == other)
17941 
 
17942 
class markOrderCancellationRequestConfirmed_result:
17943 
  """
17944 
  Attributes:
17945 
   - ex
17946 
  """
17947 
 
17948 
  thrift_spec = (
17949 
    None, # 0
17950 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17951 
  )
17952 
 
17953 
  def __init__(self, ex=None,):
17954 
    self.ex = ex
17955 
 
17956 
  def read(self, iprot):
17957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17959 
      return
17960 
    iprot.readStructBegin()
17961 
    while True:
17962 
      (fname, ftype, fid) = iprot.readFieldBegin()
17963 
      if ftype == TType.STOP:
17964 
        break
17965 
      if fid == 1:
17966 
        if ftype == TType.STRUCT:
17967 
          self.ex = TransactionServiceException()
17968 
          self.ex.read(iprot)
17969 
        else:
17970 
          iprot.skip(ftype)
17971 
      else:
17972 
        iprot.skip(ftype)
17973 
      iprot.readFieldEnd()
17974 
    iprot.readStructEnd()
17975 
 
17976 
  def write(self, oprot):
17977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17979 
      return
17980 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
17981 
    if self.ex is not None:
17982 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17983 
      self.ex.write(oprot)
17984 
      oprot.writeFieldEnd()
17985 
    oprot.writeFieldStop()
17986 
    oprot.writeStructEnd()
17987 
 
17988 
  def validate(self):
17989 
    return
17990 
 
17991 
 
17992 
  def __repr__(self):
17993 
    L = ['%s=%r' % (key, value)
17994 
      for key, value in self.__dict__.iteritems()]
17995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17996 
 
17997 
  def __eq__(self, other):
17998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17999 
 
18000 
  def __ne__(self, other):
18001 
    return not (self == other)
18002 
 
18003 
class markOrderCancellationRequestDenied_args:
18004 
  """
18005 
  Attributes:
18006 
   - orderId
18007 
  """
18008 
 
18009 
  thrift_spec = (
18010 
    None, # 0
18011 
    (1, TType.I64, 'orderId', None, None, ), # 1
18012 
  )
18013 
 
18014 
  def __init__(self, orderId=None,):
18015 
    self.orderId = orderId
18016 
 
18017 
  def read(self, iprot):
18018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18020 
      return
18021 
    iprot.readStructBegin()
18022 
    while True:
18023 
      (fname, ftype, fid) = iprot.readFieldBegin()
18024 
      if ftype == TType.STOP:
18025 
        break
18026 
      if fid == 1:
18027 
        if ftype == TType.I64:
18028 
          self.orderId = iprot.readI64();
18029 
        else:
18030 
          iprot.skip(ftype)
18031 
      else:
18032 
        iprot.skip(ftype)
18033 
      iprot.readFieldEnd()
18034 
    iprot.readStructEnd()
18035 
 
18036 
  def write(self, oprot):
18037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18039 
      return
18040 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
18041 
    if self.orderId is not None:
18042 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18043 
      oprot.writeI64(self.orderId)
18044 
      oprot.writeFieldEnd()
18045 
    oprot.writeFieldStop()
18046 
    oprot.writeStructEnd()
18047 
 
18048 
  def validate(self):
18049 
    return
18050 
 
18051 
 
18052 
  def __repr__(self):
18053 
    L = ['%s=%r' % (key, value)
18054 
      for key, value in self.__dict__.iteritems()]
18055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18056 
 
18057 
  def __eq__(self, other):
18058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18059 
 
18060 
  def __ne__(self, other):
18061 
    return not (self == other)
18062 
 
18063 
class markOrderCancellationRequestDenied_result:
18064 
  """
18065 
  Attributes:
18066 
   - ex
18067 
  """
18068 
 
18069 
  thrift_spec = (
18070 
    None, # 0
18071 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18072 
  )
18073 
 
18074 
  def __init__(self, ex=None,):
18075 
    self.ex = ex
18076 
 
18077 
  def read(self, iprot):
18078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18080 
      return
18081 
    iprot.readStructBegin()
18082 
    while True:
18083 
      (fname, ftype, fid) = iprot.readFieldBegin()
18084 
      if ftype == TType.STOP:
18085 
        break
18086 
      if fid == 1:
18087 
        if ftype == TType.STRUCT:
18088 
          self.ex = TransactionServiceException()
18089 
          self.ex.read(iprot)
18090 
        else:
18091 
          iprot.skip(ftype)
18092 
      else:
18093 
        iprot.skip(ftype)
18094 
      iprot.readFieldEnd()
18095 
    iprot.readStructEnd()
18096 
 
18097 
  def write(self, oprot):
18098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18100 
      return
18101 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
18102 
    if self.ex is not None:
18103 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18104 
      self.ex.write(oprot)
18105 
      oprot.writeFieldEnd()
18106 
    oprot.writeFieldStop()
18107 
    oprot.writeStructEnd()
18108 
 
18109 
  def validate(self):
18110 
    return
18111 
 
18112 
 
18113 
  def __repr__(self):
18114 
    L = ['%s=%r' % (key, value)
18115 
      for key, value in self.__dict__.iteritems()]
18116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18117 
 
18118 
  def __eq__(self, other):
18119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18120 
 
18121 
  def __ne__(self, other):
18122 
    return not (self == other)
18123 
 
4258 rajveer 18124 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 18125 
  """
18126 
  Attributes:
4258 rajveer 18127 
   - transactionId
4247 rajveer 18128 
  """
18129 
 
18130 
  thrift_spec = (
18131 
    None, # 0
4258 rajveer 18132 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 18133 
  )
18134 
 
4258 rajveer 18135 
  def __init__(self, transactionId=None,):
18136 
    self.transactionId = transactionId
4247 rajveer 18137 
 
18138 
  def read(self, iprot):
18139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18141 
      return
18142 
    iprot.readStructBegin()
18143 
    while True:
18144 
      (fname, ftype, fid) = iprot.readFieldBegin()
18145 
      if ftype == TType.STOP:
18146 
        break
18147 
      if fid == 1:
18148 
        if ftype == TType.I64:
4258 rajveer 18149 
          self.transactionId = iprot.readI64();
4247 rajveer 18150 
        else:
18151 
          iprot.skip(ftype)
18152 
      else:
18153 
        iprot.skip(ftype)
18154 
      iprot.readFieldEnd()
18155 
    iprot.readStructEnd()
18156 
 
18157 
  def write(self, oprot):
18158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18160 
      return
4258 rajveer 18161 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
18162 
    if self.transactionId is not None:
18163 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18164 
      oprot.writeI64(self.transactionId)
4247 rajveer 18165 
      oprot.writeFieldEnd()
18166 
    oprot.writeFieldStop()
18167 
    oprot.writeStructEnd()
18168 
 
18169 
  def validate(self):
18170 
    return
18171 
 
18172 
 
18173 
  def __repr__(self):
18174 
    L = ['%s=%r' % (key, value)
18175 
      for key, value in self.__dict__.iteritems()]
18176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18177 
 
18178 
  def __eq__(self, other):
18179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18180 
 
18181 
  def __ne__(self, other):
18182 
    return not (self == other)
18183 
 
4258 rajveer 18184 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 18185 
  """
18186 
  Attributes:
18187 
   - ex
18188 
  """
18189 
 
18190 
  thrift_spec = (
18191 
    None, # 0
18192 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18193 
  )
18194 
 
18195 
  def __init__(self, ex=None,):
18196 
    self.ex = ex
18197 
 
18198 
  def read(self, iprot):
18199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18201 
      return
18202 
    iprot.readStructBegin()
18203 
    while True:
18204 
      (fname, ftype, fid) = iprot.readFieldBegin()
18205 
      if ftype == TType.STOP:
18206 
        break
18207 
      if fid == 1:
18208 
        if ftype == TType.STRUCT:
18209 
          self.ex = TransactionServiceException()
18210 
          self.ex.read(iprot)
18211 
        else:
18212 
          iprot.skip(ftype)
18213 
      else:
18214 
        iprot.skip(ftype)
18215 
      iprot.readFieldEnd()
18216 
    iprot.readStructEnd()
18217 
 
18218 
  def write(self, oprot):
18219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18221 
      return
4258 rajveer 18222 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 18223 
    if self.ex is not None:
18224 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18225 
      self.ex.write(oprot)
18226 
      oprot.writeFieldEnd()
18227 
    oprot.writeFieldStop()
18228 
    oprot.writeStructEnd()
18229 
 
18230 
  def validate(self):
18231 
    return
18232 
 
18233 
 
18234 
  def __repr__(self):
18235 
    L = ['%s=%r' % (key, value)
18236 
      for key, value in self.__dict__.iteritems()]
18237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18238 
 
18239 
  def __eq__(self, other):
18240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18241 
 
18242 
  def __ne__(self, other):
18243 
    return not (self == other)
4259 anupam.sin 18244 
 
18245 
class refundTransaction_args:
18246 
  """
18247 
  Attributes:
18248 
   - transactionId
18249 
   - refundedBy
18250 
   - reason
18251 
  """
18252 
 
18253 
  thrift_spec = (
18254 
    None, # 0
18255 
    (1, TType.I64, 'transactionId', None, None, ), # 1
18256 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18257 
    (3, TType.STRING, 'reason', None, None, ), # 3
18258 
  )
18259 
 
18260 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
18261 
    self.transactionId = transactionId
18262 
    self.refundedBy = refundedBy
18263 
    self.reason = reason
18264 
 
18265 
  def read(self, iprot):
18266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18268 
      return
18269 
    iprot.readStructBegin()
18270 
    while True:
18271 
      (fname, ftype, fid) = iprot.readFieldBegin()
18272 
      if ftype == TType.STOP:
18273 
        break
18274 
      if fid == 1:
18275 
        if ftype == TType.I64:
18276 
          self.transactionId = iprot.readI64();
18277 
        else:
18278 
          iprot.skip(ftype)
18279 
      elif fid == 2:
18280 
        if ftype == TType.STRING:
18281 
          self.refundedBy = iprot.readString();
18282 
        else:
18283 
          iprot.skip(ftype)
18284 
      elif fid == 3:
18285 
        if ftype == TType.STRING:
18286 
          self.reason = iprot.readString();
18287 
        else:
18288 
          iprot.skip(ftype)
18289 
      else:
18290 
        iprot.skip(ftype)
18291 
      iprot.readFieldEnd()
18292 
    iprot.readStructEnd()
18293 
 
18294 
  def write(self, oprot):
18295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18297 
      return
18298 
    oprot.writeStructBegin('refundTransaction_args')
18299 
    if self.transactionId is not None:
18300 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18301 
      oprot.writeI64(self.transactionId)
18302 
      oprot.writeFieldEnd()
18303 
    if self.refundedBy is not None:
18304 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18305 
      oprot.writeString(self.refundedBy)
18306 
      oprot.writeFieldEnd()
18307 
    if self.reason is not None:
18308 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18309 
      oprot.writeString(self.reason)
18310 
      oprot.writeFieldEnd()
18311 
    oprot.writeFieldStop()
18312 
    oprot.writeStructEnd()
18313 
 
18314 
  def validate(self):
18315 
    return
18316 
 
18317 
 
18318 
  def __repr__(self):
18319 
    L = ['%s=%r' % (key, value)
18320 
      for key, value in self.__dict__.iteritems()]
18321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18322 
 
18323 
  def __eq__(self, other):
18324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18325 
 
18326 
  def __ne__(self, other):
18327 
    return not (self == other)
18328 
 
18329 
class refundTransaction_result:
18330 
  """
18331 
  Attributes:
18332 
   - ex
18333 
  """
18334 
 
18335 
  thrift_spec = (
18336 
    None, # 0
18337 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18338 
  )
18339 
 
18340 
  def __init__(self, ex=None,):
18341 
    self.ex = ex
18342 
 
18343 
  def read(self, iprot):
18344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18346 
      return
18347 
    iprot.readStructBegin()
18348 
    while True:
18349 
      (fname, ftype, fid) = iprot.readFieldBegin()
18350 
      if ftype == TType.STOP:
18351 
        break
18352 
      if fid == 1:
18353 
        if ftype == TType.STRUCT:
18354 
          self.ex = TransactionServiceException()
18355 
          self.ex.read(iprot)
18356 
        else:
18357 
          iprot.skip(ftype)
18358 
      else:
18359 
        iprot.skip(ftype)
18360 
      iprot.readFieldEnd()
18361 
    iprot.readStructEnd()
18362 
 
18363 
  def write(self, oprot):
18364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18366 
      return
18367 
    oprot.writeStructBegin('refundTransaction_result')
18368 
    if self.ex is not None:
18369 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18370 
      self.ex.write(oprot)
18371 
      oprot.writeFieldEnd()
18372 
    oprot.writeFieldStop()
18373 
    oprot.writeStructEnd()
18374 
 
18375 
  def validate(self):
18376 
    return
18377 
 
18378 
 
18379 
  def __repr__(self):
18380 
    L = ['%s=%r' % (key, value)
18381 
      for key, value in self.__dict__.iteritems()]
18382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18383 
 
18384 
  def __eq__(self, other):
18385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18386 
 
18387 
  def __ne__(self, other):
18388 
    return not (self == other)
4285 rajveer 18389 
 
4324 mandeep.dh 18390 
class updateShipmentAddress_args:
18391 
  """
18392 
  Attributes:
18393 
   - orderId
18394 
   - addressId
18395 
  """
18396 
 
18397 
  thrift_spec = (
18398 
    None, # 0
18399 
    (1, TType.I64, 'orderId', None, None, ), # 1
18400 
    (2, TType.I64, 'addressId', None, None, ), # 2
18401 
  )
18402 
 
18403 
  def __init__(self, orderId=None, addressId=None,):
18404 
    self.orderId = orderId
18405 
    self.addressId = addressId
18406 
 
18407 
  def read(self, iprot):
18408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18410 
      return
18411 
    iprot.readStructBegin()
18412 
    while True:
18413 
      (fname, ftype, fid) = iprot.readFieldBegin()
18414 
      if ftype == TType.STOP:
18415 
        break
18416 
      if fid == 1:
18417 
        if ftype == TType.I64:
18418 
          self.orderId = iprot.readI64();
18419 
        else:
18420 
          iprot.skip(ftype)
18421 
      elif fid == 2:
18422 
        if ftype == TType.I64:
18423 
          self.addressId = iprot.readI64();
18424 
        else:
18425 
          iprot.skip(ftype)
18426 
      else:
18427 
        iprot.skip(ftype)
18428 
      iprot.readFieldEnd()
18429 
    iprot.readStructEnd()
18430 
 
18431 
  def write(self, oprot):
18432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18434 
      return
18435 
    oprot.writeStructBegin('updateShipmentAddress_args')
18436 
    if self.orderId is not None:
18437 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18438 
      oprot.writeI64(self.orderId)
18439 
      oprot.writeFieldEnd()
18440 
    if self.addressId is not None:
18441 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
18442 
      oprot.writeI64(self.addressId)
18443 
      oprot.writeFieldEnd()
18444 
    oprot.writeFieldStop()
18445 
    oprot.writeStructEnd()
18446 
 
18447 
  def validate(self):
18448 
    return
18449 
 
18450 
 
18451 
  def __repr__(self):
18452 
    L = ['%s=%r' % (key, value)
18453 
      for key, value in self.__dict__.iteritems()]
18454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18455 
 
18456 
  def __eq__(self, other):
18457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18458 
 
18459 
  def __ne__(self, other):
18460 
    return not (self == other)
18461 
 
18462 
class updateShipmentAddress_result:
18463 
  """
18464 
  Attributes:
18465 
   - ex
18466 
  """
18467 
 
18468 
  thrift_spec = (
18469 
    None, # 0
18470 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18471 
  )
18472 
 
18473 
  def __init__(self, ex=None,):
18474 
    self.ex = ex
18475 
 
18476 
  def read(self, iprot):
18477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18479 
      return
18480 
    iprot.readStructBegin()
18481 
    while True:
18482 
      (fname, ftype, fid) = iprot.readFieldBegin()
18483 
      if ftype == TType.STOP:
18484 
        break
18485 
      if fid == 1:
18486 
        if ftype == TType.STRUCT:
18487 
          self.ex = TransactionServiceException()
18488 
          self.ex.read(iprot)
18489 
        else:
18490 
          iprot.skip(ftype)
18491 
      else:
18492 
        iprot.skip(ftype)
18493 
      iprot.readFieldEnd()
18494 
    iprot.readStructEnd()
18495 
 
18496 
  def write(self, oprot):
18497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18499 
      return
18500 
    oprot.writeStructBegin('updateShipmentAddress_result')
18501 
    if self.ex is not None:
18502 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18503 
      self.ex.write(oprot)
18504 
      oprot.writeFieldEnd()
18505 
    oprot.writeFieldStop()
18506 
    oprot.writeStructEnd()
18507 
 
18508 
  def validate(self):
18509 
    return
18510 
 
18511 
 
18512 
  def __repr__(self):
18513 
    L = ['%s=%r' % (key, value)
18514 
      for key, value in self.__dict__.iteritems()]
18515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18516 
 
18517 
  def __eq__(self, other):
18518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18519 
 
18520 
  def __ne__(self, other):
18521 
    return not (self == other)
18522 
 
4285 rajveer 18523 
class acceptOrdersForItemId_args:
18524 
  """
18525 
  Attributes:
18526 
   - itemId
18527 
   - inventory
18528 
  """
18529 
 
18530 
  thrift_spec = (
18531 
    None, # 0
18532 
    (1, TType.I64, 'itemId', None, None, ), # 1
18533 
    (2, TType.I64, 'inventory', None, None, ), # 2
18534 
  )
18535 
 
18536 
  def __init__(self, itemId=None, inventory=None,):
18537 
    self.itemId = itemId
18538 
    self.inventory = inventory
18539 
 
18540 
  def read(self, iprot):
18541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18543 
      return
18544 
    iprot.readStructBegin()
18545 
    while True:
18546 
      (fname, ftype, fid) = iprot.readFieldBegin()
18547 
      if ftype == TType.STOP:
18548 
        break
18549 
      if fid == 1:
18550 
        if ftype == TType.I64:
18551 
          self.itemId = iprot.readI64();
18552 
        else:
18553 
          iprot.skip(ftype)
18554 
      elif fid == 2:
18555 
        if ftype == TType.I64:
18556 
          self.inventory = iprot.readI64();
18557 
        else:
18558 
          iprot.skip(ftype)
18559 
      else:
18560 
        iprot.skip(ftype)
18561 
      iprot.readFieldEnd()
18562 
    iprot.readStructEnd()
18563 
 
18564 
  def write(self, oprot):
18565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18567 
      return
18568 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
18569 
    if self.itemId is not None:
18570 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18571 
      oprot.writeI64(self.itemId)
18572 
      oprot.writeFieldEnd()
18573 
    if self.inventory is not None:
18574 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
18575 
      oprot.writeI64(self.inventory)
18576 
      oprot.writeFieldEnd()
18577 
    oprot.writeFieldStop()
18578 
    oprot.writeStructEnd()
18579 
 
18580 
  def validate(self):
18581 
    return
18582 
 
18583 
 
18584 
  def __repr__(self):
18585 
    L = ['%s=%r' % (key, value)
18586 
      for key, value in self.__dict__.iteritems()]
18587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18588 
 
18589 
  def __eq__(self, other):
18590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18591 
 
18592 
  def __ne__(self, other):
18593 
    return not (self == other)
18594 
 
18595 
class acceptOrdersForItemId_result:
18596 
  """
18597 
  Attributes:
18598 
   - success
18599 
   - ex
18600 
  """
18601 
 
18602 
  thrift_spec = (
18603 
    (0, TType.BOOL, 'success', None, None, ), # 0
18604 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18605 
  )
18606 
 
18607 
  def __init__(self, success=None, ex=None,):
18608 
    self.success = success
18609 
    self.ex = ex
18610 
 
18611 
  def read(self, iprot):
18612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18614 
      return
18615 
    iprot.readStructBegin()
18616 
    while True:
18617 
      (fname, ftype, fid) = iprot.readFieldBegin()
18618 
      if ftype == TType.STOP:
18619 
        break
18620 
      if fid == 0:
18621 
        if ftype == TType.BOOL:
18622 
          self.success = iprot.readBool();
18623 
        else:
18624 
          iprot.skip(ftype)
18625 
      elif fid == 1:
18626 
        if ftype == TType.STRUCT:
18627 
          self.ex = TransactionServiceException()
18628 
          self.ex.read(iprot)
18629 
        else:
18630 
          iprot.skip(ftype)
18631 
      else:
18632 
        iprot.skip(ftype)
18633 
      iprot.readFieldEnd()
18634 
    iprot.readStructEnd()
18635 
 
18636 
  def write(self, oprot):
18637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18639 
      return
18640 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
18641 
    if self.success is not None:
18642 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18643 
      oprot.writeBool(self.success)
18644 
      oprot.writeFieldEnd()
18645 
    if self.ex is not None:
18646 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18647 
      self.ex.write(oprot)
18648 
      oprot.writeFieldEnd()
18649 
    oprot.writeFieldStop()
18650 
    oprot.writeStructEnd()
18651 
 
18652 
  def validate(self):
18653 
    return
18654 
 
18655 
 
18656 
  def __repr__(self):
18657 
    L = ['%s=%r' % (key, value)
18658 
      for key, value in self.__dict__.iteritems()]
18659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18660 
 
18661 
  def __eq__(self, other):
18662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18663 
 
18664 
  def __ne__(self, other):
18665 
    return not (self == other)
4303 rajveer 18666 
 
18667 
class markOrdersAsPORaised_args:
18668 
  """
18669 
  Attributes:
18670 
   - vendorId
18671 
   - itemId
18672 
   - quantity
18673 
   - estimate
4369 rajveer 18674 
   - isReminder
4303 rajveer 18675 
  """
18676 
 
18677 
  thrift_spec = (
18678 
    None, # 0
18679 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18680 
    (2, TType.I64, 'itemId', None, None, ), # 2
18681 
    (3, TType.I64, 'quantity', None, None, ), # 3
18682 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18683 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18684 
  )
18685 
 
4369 rajveer 18686 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18687 
    self.vendorId = vendorId
18688 
    self.itemId = itemId
18689 
    self.quantity = quantity
18690 
    self.estimate = estimate
4369 rajveer 18691 
    self.isReminder = isReminder
4303 rajveer 18692 
 
18693 
  def read(self, iprot):
18694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18696 
      return
18697 
    iprot.readStructBegin()
18698 
    while True:
18699 
      (fname, ftype, fid) = iprot.readFieldBegin()
18700 
      if ftype == TType.STOP:
18701 
        break
18702 
      if fid == 1:
18703 
        if ftype == TType.I64:
18704 
          self.vendorId = iprot.readI64();
18705 
        else:
18706 
          iprot.skip(ftype)
18707 
      elif fid == 2:
18708 
        if ftype == TType.I64:
18709 
          self.itemId = iprot.readI64();
18710 
        else:
18711 
          iprot.skip(ftype)
18712 
      elif fid == 3:
18713 
        if ftype == TType.I64:
18714 
          self.quantity = iprot.readI64();
18715 
        else:
18716 
          iprot.skip(ftype)
18717 
      elif fid == 4:
18718 
        if ftype == TType.I64:
18719 
          self.estimate = iprot.readI64();
18720 
        else:
18721 
          iprot.skip(ftype)
4369 rajveer 18722 
      elif fid == 5:
18723 
        if ftype == TType.BOOL:
18724 
          self.isReminder = iprot.readBool();
18725 
        else:
18726 
          iprot.skip(ftype)
4303 rajveer 18727 
      else:
18728 
        iprot.skip(ftype)
18729 
      iprot.readFieldEnd()
18730 
    iprot.readStructEnd()
18731 
 
18732 
  def write(self, oprot):
18733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18735 
      return
18736 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
18737 
    if self.vendorId is not None:
18738 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18739 
      oprot.writeI64(self.vendorId)
18740 
      oprot.writeFieldEnd()
18741 
    if self.itemId is not None:
18742 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18743 
      oprot.writeI64(self.itemId)
18744 
      oprot.writeFieldEnd()
18745 
    if self.quantity is not None:
18746 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18747 
      oprot.writeI64(self.quantity)
18748 
      oprot.writeFieldEnd()
18749 
    if self.estimate is not None:
18750 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18751 
      oprot.writeI64(self.estimate)
18752 
      oprot.writeFieldEnd()
4369 rajveer 18753 
    if self.isReminder is not None:
18754 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18755 
      oprot.writeBool(self.isReminder)
18756 
      oprot.writeFieldEnd()
4303 rajveer 18757 
    oprot.writeFieldStop()
18758 
    oprot.writeStructEnd()
18759 
 
18760 
  def validate(self):
18761 
    return
18762 
 
18763 
 
18764 
  def __repr__(self):
18765 
    L = ['%s=%r' % (key, value)
18766 
      for key, value in self.__dict__.iteritems()]
18767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18768 
 
18769 
  def __eq__(self, other):
18770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18771 
 
18772 
  def __ne__(self, other):
18773 
    return not (self == other)
18774 
 
18775 
class markOrdersAsPORaised_result:
18776 
  """
18777 
  Attributes:
18778 
   - ex
18779 
  """
18780 
 
18781 
  thrift_spec = (
18782 
    None, # 0
18783 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18784 
  )
18785 
 
18786 
  def __init__(self, ex=None,):
18787 
    self.ex = ex
18788 
 
18789 
  def read(self, iprot):
18790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18792 
      return
18793 
    iprot.readStructBegin()
18794 
    while True:
18795 
      (fname, ftype, fid) = iprot.readFieldBegin()
18796 
      if ftype == TType.STOP:
18797 
        break
18798 
      if fid == 1:
18799 
        if ftype == TType.STRUCT:
18800 
          self.ex = TransactionServiceException()
18801 
          self.ex.read(iprot)
18802 
        else:
18803 
          iprot.skip(ftype)
18804 
      else:
18805 
        iprot.skip(ftype)
18806 
      iprot.readFieldEnd()
18807 
    iprot.readStructEnd()
18808 
 
18809 
  def write(self, oprot):
18810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18812 
      return
18813 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
18814 
    if self.ex is not None:
18815 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18816 
      self.ex.write(oprot)
18817 
      oprot.writeFieldEnd()
18818 
    oprot.writeFieldStop()
18819 
    oprot.writeStructEnd()
18820 
 
18821 
  def validate(self):
18822 
    return
18823 
 
18824 
 
18825 
  def __repr__(self):
18826 
    L = ['%s=%r' % (key, value)
18827 
      for key, value in self.__dict__.iteritems()]
18828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18829 
 
18830 
  def __eq__(self, other):
18831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18832 
 
18833 
  def __ne__(self, other):
18834 
    return not (self == other)
18835 
 
18836 
class markOrdersAsReversalInitiated_args:
18837 
  """
18838 
  Attributes:
18839 
   - vendorId
18840 
   - itemId
18841 
   - quantity
18842 
   - estimate
4369 rajveer 18843 
   - isReminder
4303 rajveer 18844 
  """
18845 
 
18846 
  thrift_spec = (
18847 
    None, # 0
18848 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18849 
    (2, TType.I64, 'itemId', None, None, ), # 2
18850 
    (3, TType.I64, 'quantity', None, None, ), # 3
18851 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18852 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18853 
  )
18854 
 
4369 rajveer 18855 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18856 
    self.vendorId = vendorId
18857 
    self.itemId = itemId
18858 
    self.quantity = quantity
18859 
    self.estimate = estimate
4369 rajveer 18860 
    self.isReminder = isReminder
4303 rajveer 18861 
 
18862 
  def read(self, iprot):
18863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18865 
      return
18866 
    iprot.readStructBegin()
18867 
    while True:
18868 
      (fname, ftype, fid) = iprot.readFieldBegin()
18869 
      if ftype == TType.STOP:
18870 
        break
18871 
      if fid == 1:
18872 
        if ftype == TType.I64:
18873 
          self.vendorId = iprot.readI64();
18874 
        else:
18875 
          iprot.skip(ftype)
18876 
      elif fid == 2:
18877 
        if ftype == TType.I64:
18878 
          self.itemId = iprot.readI64();
18879 
        else:
18880 
          iprot.skip(ftype)
18881 
      elif fid == 3:
18882 
        if ftype == TType.I64:
18883 
          self.quantity = iprot.readI64();
18884 
        else:
18885 
          iprot.skip(ftype)
18886 
      elif fid == 4:
18887 
        if ftype == TType.I64:
18888 
          self.estimate = iprot.readI64();
18889 
        else:
18890 
          iprot.skip(ftype)
4369 rajveer 18891 
      elif fid == 5:
18892 
        if ftype == TType.BOOL:
18893 
          self.isReminder = iprot.readBool();
18894 
        else:
18895 
          iprot.skip(ftype)
4303 rajveer 18896 
      else:
18897 
        iprot.skip(ftype)
18898 
      iprot.readFieldEnd()
18899 
    iprot.readStructEnd()
18900 
 
18901 
  def write(self, oprot):
18902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18904 
      return
18905 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
18906 
    if self.vendorId is not None:
18907 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18908 
      oprot.writeI64(self.vendorId)
18909 
      oprot.writeFieldEnd()
18910 
    if self.itemId is not None:
18911 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18912 
      oprot.writeI64(self.itemId)
18913 
      oprot.writeFieldEnd()
18914 
    if self.quantity is not None:
18915 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18916 
      oprot.writeI64(self.quantity)
18917 
      oprot.writeFieldEnd()
18918 
    if self.estimate is not None:
18919 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18920 
      oprot.writeI64(self.estimate)
18921 
      oprot.writeFieldEnd()
4369 rajveer 18922 
    if self.isReminder is not None:
18923 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18924 
      oprot.writeBool(self.isReminder)
18925 
      oprot.writeFieldEnd()
4303 rajveer 18926 
    oprot.writeFieldStop()
18927 
    oprot.writeStructEnd()
18928 
 
18929 
  def validate(self):
18930 
    return
18931 
 
18932 
 
18933 
  def __repr__(self):
18934 
    L = ['%s=%r' % (key, value)
18935 
      for key, value in self.__dict__.iteritems()]
18936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18937 
 
18938 
  def __eq__(self, other):
18939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18940 
 
18941 
  def __ne__(self, other):
18942 
    return not (self == other)
18943 
 
18944 
class markOrdersAsReversalInitiated_result:
18945 
  """
18946 
  Attributes:
18947 
   - ex
18948 
  """
18949 
 
18950 
  thrift_spec = (
18951 
    None, # 0
18952 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18953 
  )
18954 
 
18955 
  def __init__(self, ex=None,):
18956 
    self.ex = ex
18957 
 
18958 
  def read(self, iprot):
18959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18961 
      return
18962 
    iprot.readStructBegin()
18963 
    while True:
18964 
      (fname, ftype, fid) = iprot.readFieldBegin()
18965 
      if ftype == TType.STOP:
18966 
        break
18967 
      if fid == 1:
18968 
        if ftype == TType.STRUCT:
18969 
          self.ex = TransactionServiceException()
18970 
          self.ex.read(iprot)
18971 
        else:
18972 
          iprot.skip(ftype)
18973 
      else:
18974 
        iprot.skip(ftype)
18975 
      iprot.readFieldEnd()
18976 
    iprot.readStructEnd()
18977 
 
18978 
  def write(self, oprot):
18979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18981 
      return
18982 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
18983 
    if self.ex is not None:
18984 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18985 
      self.ex.write(oprot)
18986 
      oprot.writeFieldEnd()
18987 
    oprot.writeFieldStop()
18988 
    oprot.writeStructEnd()
18989 
 
18990 
  def validate(self):
18991 
    return
18992 
 
18993 
 
18994 
  def __repr__(self):
18995 
    L = ['%s=%r' % (key, value)
18996 
      for key, value in self.__dict__.iteritems()]
18997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18998 
 
18999 
  def __eq__(self, other):
19000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19001 
 
19002 
  def __ne__(self, other):
19003 
    return not (self == other)
19004 
 
19005 
class markOrdersAsNotAvailabke_args:
19006 
  """
19007 
  Attributes:
19008 
   - vendorId
19009 
   - itemId
19010 
   - quantity
19011 
   - estimate
4369 rajveer 19012 
   - isReminder
4303 rajveer 19013 
  """
19014 
 
19015 
  thrift_spec = (
19016 
    None, # 0
19017 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19018 
    (2, TType.I64, 'itemId', None, None, ), # 2
19019 
    (3, TType.I64, 'quantity', None, None, ), # 3
19020 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 19021 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 19022 
  )
19023 
 
4369 rajveer 19024 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 19025 
    self.vendorId = vendorId
19026 
    self.itemId = itemId
19027 
    self.quantity = quantity
19028 
    self.estimate = estimate
4369 rajveer 19029 
    self.isReminder = isReminder
4303 rajveer 19030 
 
19031 
  def read(self, iprot):
19032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19034 
      return
19035 
    iprot.readStructBegin()
19036 
    while True:
19037 
      (fname, ftype, fid) = iprot.readFieldBegin()
19038 
      if ftype == TType.STOP:
19039 
        break
19040 
      if fid == 1:
19041 
        if ftype == TType.I64:
19042 
          self.vendorId = iprot.readI64();
19043 
        else:
19044 
          iprot.skip(ftype)
19045 
      elif fid == 2:
19046 
        if ftype == TType.I64:
19047 
          self.itemId = iprot.readI64();
19048 
        else:
19049 
          iprot.skip(ftype)
19050 
      elif fid == 3:
19051 
        if ftype == TType.I64:
19052 
          self.quantity = iprot.readI64();
19053 
        else:
19054 
          iprot.skip(ftype)
19055 
      elif fid == 4:
19056 
        if ftype == TType.I64:
19057 
          self.estimate = iprot.readI64();
19058 
        else:
19059 
          iprot.skip(ftype)
4369 rajveer 19060 
      elif fid == 5:
19061 
        if ftype == TType.BOOL:
19062 
          self.isReminder = iprot.readBool();
19063 
        else:
19064 
          iprot.skip(ftype)
4303 rajveer 19065 
      else:
19066 
        iprot.skip(ftype)
19067 
      iprot.readFieldEnd()
19068 
    iprot.readStructEnd()
19069 
 
19070 
  def write(self, oprot):
19071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19073 
      return
19074 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
19075 
    if self.vendorId is not None:
19076 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19077 
      oprot.writeI64(self.vendorId)
19078 
      oprot.writeFieldEnd()
19079 
    if self.itemId is not None:
19080 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19081 
      oprot.writeI64(self.itemId)
19082 
      oprot.writeFieldEnd()
19083 
    if self.quantity is not None:
19084 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
19085 
      oprot.writeI64(self.quantity)
19086 
      oprot.writeFieldEnd()
19087 
    if self.estimate is not None:
19088 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
19089 
      oprot.writeI64(self.estimate)
19090 
      oprot.writeFieldEnd()
4369 rajveer 19091 
    if self.isReminder is not None:
19092 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19093 
      oprot.writeBool(self.isReminder)
19094 
      oprot.writeFieldEnd()
4303 rajveer 19095 
    oprot.writeFieldStop()
19096 
    oprot.writeStructEnd()
19097 
 
19098 
  def validate(self):
19099 
    return
19100 
 
19101 
 
19102 
  def __repr__(self):
19103 
    L = ['%s=%r' % (key, value)
19104 
      for key, value in self.__dict__.iteritems()]
19105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19106 
 
19107 
  def __eq__(self, other):
19108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19109 
 
19110 
  def __ne__(self, other):
19111 
    return not (self == other)
19112 
 
19113 
class markOrdersAsNotAvailabke_result:
19114 
  """
19115 
  Attributes:
19116 
   - ex
19117 
  """
19118 
 
19119 
  thrift_spec = (
19120 
    None, # 0
19121 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19122 
  )
19123 
 
19124 
  def __init__(self, ex=None,):
19125 
    self.ex = ex
19126 
 
19127 
  def read(self, iprot):
19128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19130 
      return
19131 
    iprot.readStructBegin()
19132 
    while True:
19133 
      (fname, ftype, fid) = iprot.readFieldBegin()
19134 
      if ftype == TType.STOP:
19135 
        break
19136 
      if fid == 1:
19137 
        if ftype == TType.STRUCT:
19138 
          self.ex = TransactionServiceException()
19139 
          self.ex.read(iprot)
19140 
        else:
19141 
          iprot.skip(ftype)
19142 
      else:
19143 
        iprot.skip(ftype)
19144 
      iprot.readFieldEnd()
19145 
    iprot.readStructEnd()
19146 
 
19147 
  def write(self, oprot):
19148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19150 
      return
19151 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
19152 
    if self.ex is not None:
19153 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19154 
      self.ex.write(oprot)
19155 
      oprot.writeFieldEnd()
19156 
    oprot.writeFieldStop()
19157 
    oprot.writeStructEnd()
19158 
 
19159 
  def validate(self):
19160 
    return
19161 
 
19162 
 
19163 
  def __repr__(self):
19164 
    L = ['%s=%r' % (key, value)
19165 
      for key, value in self.__dict__.iteritems()]
19166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19167 
 
19168 
  def __eq__(self, other):
19169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19170 
 
19171 
  def __ne__(self, other):
19172 
    return not (self == other)
4369 rajveer 19173 
 
19174 
class markOrdersAsTimeout_args:
19175 
  """
19176 
  Attributes:
19177 
   - vendorId
19178 
  """
19179 
 
19180 
  thrift_spec = (
19181 
    None, # 0
19182 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19183 
  )
19184 
 
19185 
  def __init__(self, vendorId=None,):
19186 
    self.vendorId = vendorId
19187 
 
19188 
  def read(self, iprot):
19189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19191 
      return
19192 
    iprot.readStructBegin()
19193 
    while True:
19194 
      (fname, ftype, fid) = iprot.readFieldBegin()
19195 
      if ftype == TType.STOP:
19196 
        break
19197 
      if fid == 1:
19198 
        if ftype == TType.I64:
19199 
          self.vendorId = iprot.readI64();
19200 
        else:
19201 
          iprot.skip(ftype)
19202 
      else:
19203 
        iprot.skip(ftype)
19204 
      iprot.readFieldEnd()
19205 
    iprot.readStructEnd()
19206 
 
19207 
  def write(self, oprot):
19208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19210 
      return
19211 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
19212 
    if self.vendorId is not None:
19213 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19214 
      oprot.writeI64(self.vendorId)
19215 
      oprot.writeFieldEnd()
19216 
    oprot.writeFieldStop()
19217 
    oprot.writeStructEnd()
19218 
 
19219 
  def validate(self):
19220 
    return
19221 
 
19222 
 
19223 
  def __repr__(self):
19224 
    L = ['%s=%r' % (key, value)
19225 
      for key, value in self.__dict__.iteritems()]
19226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19227 
 
19228 
  def __eq__(self, other):
19229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19230 
 
19231 
  def __ne__(self, other):
19232 
    return not (self == other)
19233 
 
19234 
class markOrdersAsTimeout_result:
19235 
  """
19236 
  Attributes:
19237 
   - success
19238 
   - ex
19239 
  """
19240 
 
19241 
  thrift_spec = (
19242 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
19243 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19244 
  )
19245 
 
19246 
  def __init__(self, success=None, ex=None,):
19247 
    self.success = success
19248 
    self.ex = ex
19249 
 
19250 
  def read(self, iprot):
19251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19253 
      return
19254 
    iprot.readStructBegin()
19255 
    while True:
19256 
      (fname, ftype, fid) = iprot.readFieldBegin()
19257 
      if ftype == TType.STOP:
19258 
        break
19259 
      if fid == 0:
19260 
        if ftype == TType.MAP:
19261 
          self.success = {}
5031 varun.gupt 19262 
          (_ktype410, _vtype411, _size409 ) = iprot.readMapBegin()
19263 
          for _i413 in xrange(_size409):
19264 
            _key414 = iprot.readI32();
19265 
            _val415 = TimeoutSummary()
19266 
            _val415.read(iprot)
19267 
            self.success[_key414] = _val415
4369 rajveer 19268 
          iprot.readMapEnd()
19269 
        else:
19270 
          iprot.skip(ftype)
19271 
      elif fid == 1:
19272 
        if ftype == TType.STRUCT:
19273 
          self.ex = TransactionServiceException()
19274 
          self.ex.read(iprot)
19275 
        else:
19276 
          iprot.skip(ftype)
19277 
      else:
19278 
        iprot.skip(ftype)
19279 
      iprot.readFieldEnd()
19280 
    iprot.readStructEnd()
19281 
 
19282 
  def write(self, oprot):
19283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19285 
      return
19286 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
19287 
    if self.success is not None:
19288 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19289 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
5031 varun.gupt 19290 
      for kiter416,viter417 in self.success.items():
19291 
        oprot.writeI32(kiter416)
19292 
        viter417.write(oprot)
4369 rajveer 19293 
      oprot.writeMapEnd()
19294 
      oprot.writeFieldEnd()
19295 
    if self.ex is not None:
19296 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19297 
      self.ex.write(oprot)
19298 
      oprot.writeFieldEnd()
19299 
    oprot.writeFieldStop()
19300 
    oprot.writeStructEnd()
19301 
 
19302 
  def validate(self):
19303 
    return
19304 
 
19305 
 
19306 
  def __repr__(self):
19307 
    L = ['%s=%r' % (key, value)
19308 
      for key, value in self.__dict__.iteritems()]
19309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19310 
 
19311 
  def __eq__(self, other):
19312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19313 
 
19314 
  def __ne__(self, other):
19315 
    return not (self == other)
4386 anupam.sin 19316 
 
4662 rajveer 19317 
class markOrderAsLostInTransit_args:
19318 
  """
19319 
  Attributes:
19320 
   - orderId
19321 
  """
19322 
 
19323 
  thrift_spec = (
19324 
    None, # 0
19325 
    (1, TType.I64, 'orderId', None, None, ), # 1
19326 
  )
19327 
 
19328 
  def __init__(self, orderId=None,):
19329 
    self.orderId = orderId
19330 
 
19331 
  def read(self, iprot):
19332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19334 
      return
19335 
    iprot.readStructBegin()
19336 
    while True:
19337 
      (fname, ftype, fid) = iprot.readFieldBegin()
19338 
      if ftype == TType.STOP:
19339 
        break
19340 
      if fid == 1:
19341 
        if ftype == TType.I64:
19342 
          self.orderId = iprot.readI64();
19343 
        else:
19344 
          iprot.skip(ftype)
19345 
      else:
19346 
        iprot.skip(ftype)
19347 
      iprot.readFieldEnd()
19348 
    iprot.readStructEnd()
19349 
 
19350 
  def write(self, oprot):
19351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19353 
      return
19354 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
19355 
    if self.orderId is not None:
19356 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19357 
      oprot.writeI64(self.orderId)
19358 
      oprot.writeFieldEnd()
19359 
    oprot.writeFieldStop()
19360 
    oprot.writeStructEnd()
19361 
 
19362 
  def validate(self):
19363 
    return
19364 
 
19365 
 
19366 
  def __repr__(self):
19367 
    L = ['%s=%r' % (key, value)
19368 
      for key, value in self.__dict__.iteritems()]
19369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19370 
 
19371 
  def __eq__(self, other):
19372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19373 
 
19374 
  def __ne__(self, other):
19375 
    return not (self == other)
19376 
 
19377 
class markOrderAsLostInTransit_result:
19378 
  """
19379 
  Attributes:
19380 
   - success
19381 
   - ex
19382 
  """
19383 
 
19384 
  thrift_spec = (
19385 
    (0, TType.BOOL, 'success', None, None, ), # 0
19386 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19387 
  )
19388 
 
19389 
  def __init__(self, success=None, ex=None,):
19390 
    self.success = success
19391 
    self.ex = ex
19392 
 
19393 
  def read(self, iprot):
19394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19396 
      return
19397 
    iprot.readStructBegin()
19398 
    while True:
19399 
      (fname, ftype, fid) = iprot.readFieldBegin()
19400 
      if ftype == TType.STOP:
19401 
        break
19402 
      if fid == 0:
19403 
        if ftype == TType.BOOL:
19404 
          self.success = iprot.readBool();
19405 
        else:
19406 
          iprot.skip(ftype)
19407 
      elif fid == 1:
19408 
        if ftype == TType.STRUCT:
19409 
          self.ex = TransactionServiceException()
19410 
          self.ex.read(iprot)
19411 
        else:
19412 
          iprot.skip(ftype)
19413 
      else:
19414 
        iprot.skip(ftype)
19415 
      iprot.readFieldEnd()
19416 
    iprot.readStructEnd()
19417 
 
19418 
  def write(self, oprot):
19419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19421 
      return
19422 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
19423 
    if self.success is not None:
19424 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19425 
      oprot.writeBool(self.success)
19426 
      oprot.writeFieldEnd()
19427 
    if self.ex is not None:
19428 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19429 
      self.ex.write(oprot)
19430 
      oprot.writeFieldEnd()
19431 
    oprot.writeFieldStop()
19432 
    oprot.writeStructEnd()
19433 
 
19434 
  def validate(self):
19435 
    return
19436 
 
19437 
 
19438 
  def __repr__(self):
19439 
    L = ['%s=%r' % (key, value)
19440 
      for key, value in self.__dict__.iteritems()]
19441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19442 
 
19443 
  def __eq__(self, other):
19444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19445 
 
19446 
  def __ne__(self, other):
19447 
    return not (self == other)
19448 
 
4386 anupam.sin 19449 
class getOrderForAwb_args:
19450 
  """
19451 
  Attributes:
19452 
   - awb
19453 
  """
19454 
 
19455 
  thrift_spec = (
19456 
    None, # 0
19457 
    (1, TType.STRING, 'awb', None, None, ), # 1
19458 
  )
19459 
 
19460 
  def __init__(self, awb=None,):
19461 
    self.awb = awb
19462 
 
19463 
  def read(self, iprot):
19464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19466 
      return
19467 
    iprot.readStructBegin()
19468 
    while True:
19469 
      (fname, ftype, fid) = iprot.readFieldBegin()
19470 
      if ftype == TType.STOP:
19471 
        break
19472 
      if fid == 1:
19473 
        if ftype == TType.STRING:
19474 
          self.awb = iprot.readString();
19475 
        else:
19476 
          iprot.skip(ftype)
19477 
      else:
19478 
        iprot.skip(ftype)
19479 
      iprot.readFieldEnd()
19480 
    iprot.readStructEnd()
19481 
 
19482 
  def write(self, oprot):
19483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19485 
      return
19486 
    oprot.writeStructBegin('getOrderForAwb_args')
19487 
    if self.awb is not None:
19488 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
19489 
      oprot.writeString(self.awb)
19490 
      oprot.writeFieldEnd()
19491 
    oprot.writeFieldStop()
19492 
    oprot.writeStructEnd()
19493 
 
19494 
  def validate(self):
19495 
    return
19496 
 
19497 
 
19498 
  def __repr__(self):
19499 
    L = ['%s=%r' % (key, value)
19500 
      for key, value in self.__dict__.iteritems()]
19501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19502 
 
19503 
  def __eq__(self, other):
19504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19505 
 
19506 
  def __ne__(self, other):
19507 
    return not (self == other)
19508 
 
19509 
class getOrderForAwb_result:
19510 
  """
19511 
  Attributes:
19512 
   - success
19513 
   - ex
19514 
  """
19515 
 
19516 
  thrift_spec = (
19517 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19518 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19519 
  )
19520 
 
19521 
  def __init__(self, success=None, ex=None,):
19522 
    self.success = success
19523 
    self.ex = ex
19524 
 
19525 
  def read(self, iprot):
19526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19528 
      return
19529 
    iprot.readStructBegin()
19530 
    while True:
19531 
      (fname, ftype, fid) = iprot.readFieldBegin()
19532 
      if ftype == TType.STOP:
19533 
        break
19534 
      if fid == 0:
19535 
        if ftype == TType.STRUCT:
19536 
          self.success = Order()
19537 
          self.success.read(iprot)
19538 
        else:
19539 
          iprot.skip(ftype)
19540 
      elif fid == 1:
19541 
        if ftype == TType.STRUCT:
19542 
          self.ex = TransactionServiceException()
19543 
          self.ex.read(iprot)
19544 
        else:
19545 
          iprot.skip(ftype)
19546 
      else:
19547 
        iprot.skip(ftype)
19548 
      iprot.readFieldEnd()
19549 
    iprot.readStructEnd()
19550 
 
19551 
  def write(self, oprot):
19552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19554 
      return
19555 
    oprot.writeStructBegin('getOrderForAwb_result')
19556 
    if self.success is not None:
19557 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19558 
      self.success.write(oprot)
19559 
      oprot.writeFieldEnd()
19560 
    if self.ex is not None:
19561 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19562 
      self.ex.write(oprot)
19563 
      oprot.writeFieldEnd()
19564 
    oprot.writeFieldStop()
19565 
    oprot.writeStructEnd()
19566 
 
19567 
  def validate(self):
19568 
    return
19569 
 
19570 
 
19571 
  def __repr__(self):
19572 
    L = ['%s=%r' % (key, value)
19573 
      for key, value in self.__dict__.iteritems()]
19574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19575 
 
19576 
  def __eq__(self, other):
19577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19578 
 
19579 
  def __ne__(self, other):
19580 
    return not (self == other)
4506 phani.kuma 19581 
 
19582 
class getOrdersForProviderForStatus_args:
19583 
  """
19584 
  Attributes:
19585 
   - logistics_provider_id
4910 phani.kuma 19586 
   - order_status_list
4506 phani.kuma 19587 
  """
19588 
 
19589 
  thrift_spec = (
19590 
    None, # 0
19591 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 19592 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 19593 
  )
19594 
 
4910 phani.kuma 19595 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 19596 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 19597 
    self.order_status_list = order_status_list
4506 phani.kuma 19598 
 
19599 
  def read(self, iprot):
19600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19602 
      return
19603 
    iprot.readStructBegin()
19604 
    while True:
19605 
      (fname, ftype, fid) = iprot.readFieldBegin()
19606 
      if ftype == TType.STOP:
19607 
        break
19608 
      if fid == 1:
19609 
        if ftype == TType.I64:
19610 
          self.logistics_provider_id = iprot.readI64();
19611 
        else:
19612 
          iprot.skip(ftype)
19613 
      elif fid == 2:
4910 phani.kuma 19614 
        if ftype == TType.LIST:
19615 
          self.order_status_list = []
5031 varun.gupt 19616 
          (_etype421, _size418) = iprot.readListBegin()
19617 
          for _i422 in xrange(_size418):
19618 
            _elem423 = iprot.readI32();
19619 
            self.order_status_list.append(_elem423)
4910 phani.kuma 19620 
          iprot.readListEnd()
4506 phani.kuma 19621 
        else:
19622 
          iprot.skip(ftype)
19623 
      else:
19624 
        iprot.skip(ftype)
19625 
      iprot.readFieldEnd()
19626 
    iprot.readStructEnd()
19627 
 
19628 
  def write(self, oprot):
19629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19631 
      return
19632 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
19633 
    if self.logistics_provider_id is not None:
19634 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
19635 
      oprot.writeI64(self.logistics_provider_id)
19636 
      oprot.writeFieldEnd()
4910 phani.kuma 19637 
    if self.order_status_list is not None:
19638 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
19639 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
5031 varun.gupt 19640 
      for iter424 in self.order_status_list:
19641 
        oprot.writeI32(iter424)
4910 phani.kuma 19642 
      oprot.writeListEnd()
4506 phani.kuma 19643 
      oprot.writeFieldEnd()
19644 
    oprot.writeFieldStop()
19645 
    oprot.writeStructEnd()
19646 
 
19647 
  def validate(self):
19648 
    return
19649 
 
19650 
 
19651 
  def __repr__(self):
19652 
    L = ['%s=%r' % (key, value)
19653 
      for key, value in self.__dict__.iteritems()]
19654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19655 
 
19656 
  def __eq__(self, other):
19657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19658 
 
19659 
  def __ne__(self, other):
19660 
    return not (self == other)
19661 
 
19662 
class getOrdersForProviderForStatus_result:
19663 
  """
19664 
  Attributes:
19665 
   - success
19666 
   - ex
19667 
  """
19668 
 
19669 
  thrift_spec = (
19670 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19671 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19672 
  )
19673 
 
19674 
  def __init__(self, success=None, ex=None,):
19675 
    self.success = success
19676 
    self.ex = ex
19677 
 
19678 
  def read(self, iprot):
19679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19681 
      return
19682 
    iprot.readStructBegin()
19683 
    while True:
19684 
      (fname, ftype, fid) = iprot.readFieldBegin()
19685 
      if ftype == TType.STOP:
19686 
        break
19687 
      if fid == 0:
19688 
        if ftype == TType.LIST:
19689 
          self.success = []
5031 varun.gupt 19690 
          (_etype428, _size425) = iprot.readListBegin()
19691 
          for _i429 in xrange(_size425):
19692 
            _elem430 = Order()
19693 
            _elem430.read(iprot)
19694 
            self.success.append(_elem430)
4506 phani.kuma 19695 
          iprot.readListEnd()
19696 
        else:
19697 
          iprot.skip(ftype)
19698 
      elif fid == 1:
19699 
        if ftype == TType.STRUCT:
19700 
          self.ex = TransactionServiceException()
19701 
          self.ex.read(iprot)
19702 
        else:
19703 
          iprot.skip(ftype)
19704 
      else:
19705 
        iprot.skip(ftype)
19706 
      iprot.readFieldEnd()
19707 
    iprot.readStructEnd()
19708 
 
19709 
  def write(self, oprot):
19710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19712 
      return
19713 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
19714 
    if self.success is not None:
19715 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19716 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19717 
      for iter431 in self.success:
19718 
        iter431.write(oprot)
4506 phani.kuma 19719 
      oprot.writeListEnd()
19720 
      oprot.writeFieldEnd()
19721 
    if self.ex is not None:
19722 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19723 
      self.ex.write(oprot)
19724 
      oprot.writeFieldEnd()
19725 
    oprot.writeFieldStop()
19726 
    oprot.writeStructEnd()
19727 
 
19728 
  def validate(self):
19729 
    return
19730 
 
19731 
 
19732 
  def __repr__(self):
19733 
    L = ['%s=%r' % (key, value)
19734 
      for key, value in self.__dict__.iteritems()]
19735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19736 
 
19737 
  def __eq__(self, other):
19738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19739 
 
19740 
  def __ne__(self, other):
19741 
    return not (self == other)
4600 varun.gupt 19742 
 
19743 
class getBilledOrdersForVendor_args:
19744 
  """
19745 
  Attributes:
19746 
   - vendorId
19747 
   - billingDateFrom
19748 
   - billingDateTo
19749 
  """
19750 
 
19751 
  thrift_spec = (
19752 
    None, # 0
19753 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19754 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
19755 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
19756 
  )
19757 
 
19758 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
19759 
    self.vendorId = vendorId
19760 
    self.billingDateFrom = billingDateFrom
19761 
    self.billingDateTo = billingDateTo
19762 
 
19763 
  def read(self, iprot):
19764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19766 
      return
19767 
    iprot.readStructBegin()
19768 
    while True:
19769 
      (fname, ftype, fid) = iprot.readFieldBegin()
19770 
      if ftype == TType.STOP:
19771 
        break
19772 
      if fid == 1:
19773 
        if ftype == TType.I64:
19774 
          self.vendorId = iprot.readI64();
19775 
        else:
19776 
          iprot.skip(ftype)
19777 
      elif fid == 2:
19778 
        if ftype == TType.I64:
19779 
          self.billingDateFrom = iprot.readI64();
19780 
        else:
19781 
          iprot.skip(ftype)
19782 
      elif fid == 3:
19783 
        if ftype == TType.I64:
19784 
          self.billingDateTo = iprot.readI64();
19785 
        else:
19786 
          iprot.skip(ftype)
19787 
      else:
19788 
        iprot.skip(ftype)
19789 
      iprot.readFieldEnd()
19790 
    iprot.readStructEnd()
19791 
 
19792 
  def write(self, oprot):
19793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19795 
      return
19796 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
19797 
    if self.vendorId is not None:
19798 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19799 
      oprot.writeI64(self.vendorId)
19800 
      oprot.writeFieldEnd()
19801 
    if self.billingDateFrom is not None:
19802 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
19803 
      oprot.writeI64(self.billingDateFrom)
19804 
      oprot.writeFieldEnd()
19805 
    if self.billingDateTo is not None:
19806 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
19807 
      oprot.writeI64(self.billingDateTo)
19808 
      oprot.writeFieldEnd()
19809 
    oprot.writeFieldStop()
19810 
    oprot.writeStructEnd()
19811 
 
19812 
  def validate(self):
19813 
    return
19814 
 
19815 
 
19816 
  def __repr__(self):
19817 
    L = ['%s=%r' % (key, value)
19818 
      for key, value in self.__dict__.iteritems()]
19819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19820 
 
19821 
  def __eq__(self, other):
19822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19823 
 
19824 
  def __ne__(self, other):
19825 
    return not (self == other)
19826 
 
19827 
class getBilledOrdersForVendor_result:
19828 
  """
19829 
  Attributes:
19830 
   - success
19831 
   - ex
19832 
  """
19833 
 
19834 
  thrift_spec = (
19835 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19836 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19837 
  )
19838 
 
19839 
  def __init__(self, success=None, ex=None,):
19840 
    self.success = success
19841 
    self.ex = ex
19842 
 
19843 
  def read(self, iprot):
19844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19846 
      return
19847 
    iprot.readStructBegin()
19848 
    while True:
19849 
      (fname, ftype, fid) = iprot.readFieldBegin()
19850 
      if ftype == TType.STOP:
19851 
        break
19852 
      if fid == 0:
19853 
        if ftype == TType.LIST:
19854 
          self.success = []
5031 varun.gupt 19855 
          (_etype435, _size432) = iprot.readListBegin()
19856 
          for _i436 in xrange(_size432):
19857 
            _elem437 = Order()
19858 
            _elem437.read(iprot)
19859 
            self.success.append(_elem437)
4600 varun.gupt 19860 
          iprot.readListEnd()
19861 
        else:
19862 
          iprot.skip(ftype)
19863 
      elif fid == 1:
19864 
        if ftype == TType.STRUCT:
19865 
          self.ex = TransactionServiceException()
19866 
          self.ex.read(iprot)
19867 
        else:
19868 
          iprot.skip(ftype)
19869 
      else:
19870 
        iprot.skip(ftype)
19871 
      iprot.readFieldEnd()
19872 
    iprot.readStructEnd()
19873 
 
19874 
  def write(self, oprot):
19875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19877 
      return
19878 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
19879 
    if self.success is not None:
19880 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19881 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19882 
      for iter438 in self.success:
19883 
        iter438.write(oprot)
4600 varun.gupt 19884 
      oprot.writeListEnd()
19885 
      oprot.writeFieldEnd()
19886 
    if self.ex is not None:
19887 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19888 
      self.ex.write(oprot)
19889 
      oprot.writeFieldEnd()
19890 
    oprot.writeFieldStop()
19891 
    oprot.writeStructEnd()
19892 
 
19893 
  def validate(self):
19894 
    return
19895 
 
19896 
 
19897 
  def __repr__(self):
19898 
    L = ['%s=%r' % (key, value)
19899 
      for key, value in self.__dict__.iteritems()]
19900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19901 
 
19902 
  def __eq__(self, other):
19903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19904 
 
19905 
  def __ne__(self, other):
19906 
    return not (self == other)
19907 
 
4607 rajveer 19908 
class getSlippedSippingDateOrders_args:
19909 
 
19910 
  thrift_spec = (
19911 
  )
19912 
 
19913 
  def read(self, iprot):
19914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19916 
      return
19917 
    iprot.readStructBegin()
19918 
    while True:
19919 
      (fname, ftype, fid) = iprot.readFieldBegin()
19920 
      if ftype == TType.STOP:
19921 
        break
19922 
      else:
19923 
        iprot.skip(ftype)
19924 
      iprot.readFieldEnd()
19925 
    iprot.readStructEnd()
19926 
 
19927 
  def write(self, oprot):
19928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19930 
      return
19931 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
19932 
    oprot.writeFieldStop()
19933 
    oprot.writeStructEnd()
19934 
 
19935 
  def validate(self):
19936 
    return
19937 
 
19938 
 
19939 
  def __repr__(self):
19940 
    L = ['%s=%r' % (key, value)
19941 
      for key, value in self.__dict__.iteritems()]
19942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19943 
 
19944 
  def __eq__(self, other):
19945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19946 
 
19947 
  def __ne__(self, other):
19948 
    return not (self == other)
19949 
 
19950 
class getSlippedSippingDateOrders_result:
19951 
  """
19952 
  Attributes:
19953 
   - success
19954 
   - ex
19955 
  """
19956 
 
19957 
  thrift_spec = (
19958 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19959 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19960 
  )
19961 
 
19962 
  def __init__(self, success=None, ex=None,):
19963 
    self.success = success
19964 
    self.ex = ex
19965 
 
19966 
  def read(self, iprot):
19967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19969 
      return
19970 
    iprot.readStructBegin()
19971 
    while True:
19972 
      (fname, ftype, fid) = iprot.readFieldBegin()
19973 
      if ftype == TType.STOP:
19974 
        break
19975 
      if fid == 0:
19976 
        if ftype == TType.LIST:
19977 
          self.success = []
5031 varun.gupt 19978 
          (_etype442, _size439) = iprot.readListBegin()
19979 
          for _i443 in xrange(_size439):
19980 
            _elem444 = Order()
19981 
            _elem444.read(iprot)
19982 
            self.success.append(_elem444)
4607 rajveer 19983 
          iprot.readListEnd()
19984 
        else:
19985 
          iprot.skip(ftype)
19986 
      elif fid == 1:
19987 
        if ftype == TType.STRUCT:
19988 
          self.ex = TransactionServiceException()
19989 
          self.ex.read(iprot)
19990 
        else:
19991 
          iprot.skip(ftype)
19992 
      else:
19993 
        iprot.skip(ftype)
19994 
      iprot.readFieldEnd()
19995 
    iprot.readStructEnd()
19996 
 
19997 
  def write(self, oprot):
19998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20000 
      return
20001 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
20002 
    if self.success is not None:
20003 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20004 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 20005 
      for iter445 in self.success:
20006 
        iter445.write(oprot)
4607 rajveer 20007 
      oprot.writeListEnd()
20008 
      oprot.writeFieldEnd()
20009 
    if self.ex is not None:
20010 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20011 
      self.ex.write(oprot)
20012 
      oprot.writeFieldEnd()
20013 
    oprot.writeFieldStop()
20014 
    oprot.writeStructEnd()
20015 
 
20016 
  def validate(self):
20017 
    return
20018 
 
20019 
 
20020 
  def __repr__(self):
20021 
    L = ['%s=%r' % (key, value)
20022 
      for key, value in self.__dict__.iteritems()]
20023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20024 
 
20025 
  def __eq__(self, other):
20026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20027 
 
20028 
  def __ne__(self, other):
20029 
    return not (self == other)
20030 
 
4709 rajveer 20031 
class getCancelledOrders_args:
20032 
  """
20033 
  Attributes:
20034 
   - cancelDateFrom
20035 
   - cancelDateTo
20036 
  """
20037 
 
20038 
  thrift_spec = (
20039 
    None, # 0
20040 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
20041 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
20042 
  )
20043 
 
20044 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
20045 
    self.cancelDateFrom = cancelDateFrom
20046 
    self.cancelDateTo = cancelDateTo
20047 
 
20048 
  def read(self, iprot):
20049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20051 
      return
20052 
    iprot.readStructBegin()
20053 
    while True:
20054 
      (fname, ftype, fid) = iprot.readFieldBegin()
20055 
      if ftype == TType.STOP:
20056 
        break
20057 
      if fid == 1:
20058 
        if ftype == TType.I64:
20059 
          self.cancelDateFrom = iprot.readI64();
20060 
        else:
20061 
          iprot.skip(ftype)
20062 
      elif fid == 2:
20063 
        if ftype == TType.I64:
20064 
          self.cancelDateTo = iprot.readI64();
20065 
        else:
20066 
          iprot.skip(ftype)
20067 
      else:
20068 
        iprot.skip(ftype)
20069 
      iprot.readFieldEnd()
20070 
    iprot.readStructEnd()
20071 
 
20072 
  def write(self, oprot):
20073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20075 
      return
20076 
    oprot.writeStructBegin('getCancelledOrders_args')
20077 
    if self.cancelDateFrom is not None:
20078 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
20079 
      oprot.writeI64(self.cancelDateFrom)
20080 
      oprot.writeFieldEnd()
20081 
    if self.cancelDateTo is not None:
20082 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
20083 
      oprot.writeI64(self.cancelDateTo)
20084 
      oprot.writeFieldEnd()
20085 
    oprot.writeFieldStop()
20086 
    oprot.writeStructEnd()
20087 
 
20088 
  def validate(self):
20089 
    return
20090 
 
20091 
 
20092 
  def __repr__(self):
20093 
    L = ['%s=%r' % (key, value)
20094 
      for key, value in self.__dict__.iteritems()]
20095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20096 
 
20097 
  def __eq__(self, other):
20098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20099 
 
20100 
  def __ne__(self, other):
20101 
    return not (self == other)
20102 
 
20103 
class getCancelledOrders_result:
20104 
  """
20105 
  Attributes:
20106 
   - success
20107 
   - ex
20108 
  """
20109 
 
20110 
  thrift_spec = (
20111 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20112 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20113 
  )
20114 
 
20115 
  def __init__(self, success=None, ex=None,):
20116 
    self.success = success
20117 
    self.ex = ex
20118 
 
20119 
  def read(self, iprot):
20120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20122 
      return
20123 
    iprot.readStructBegin()
20124 
    while True:
20125 
      (fname, ftype, fid) = iprot.readFieldBegin()
20126 
      if ftype == TType.STOP:
20127 
        break
20128 
      if fid == 0:
20129 
        if ftype == TType.LIST:
20130 
          self.success = []
5031 varun.gupt 20131 
          (_etype449, _size446) = iprot.readListBegin()
20132 
          for _i450 in xrange(_size446):
20133 
            _elem451 = Order()
20134 
            _elem451.read(iprot)
20135 
            self.success.append(_elem451)
4709 rajveer 20136 
          iprot.readListEnd()
20137 
        else:
20138 
          iprot.skip(ftype)
20139 
      elif fid == 1:
20140 
        if ftype == TType.STRUCT:
20141 
          self.ex = TransactionServiceException()
20142 
          self.ex.read(iprot)
20143 
        else:
20144 
          iprot.skip(ftype)
20145 
      else:
20146 
        iprot.skip(ftype)
20147 
      iprot.readFieldEnd()
20148 
    iprot.readStructEnd()
20149 
 
20150 
  def write(self, oprot):
20151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20153 
      return
20154 
    oprot.writeStructBegin('getCancelledOrders_result')
20155 
    if self.success is not None:
20156 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20157 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 20158 
      for iter452 in self.success:
20159 
        iter452.write(oprot)
4709 rajveer 20160 
      oprot.writeListEnd()
20161 
      oprot.writeFieldEnd()
20162 
    if self.ex is not None:
20163 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20164 
      self.ex.write(oprot)
20165 
      oprot.writeFieldEnd()
20166 
    oprot.writeFieldStop()
20167 
    oprot.writeStructEnd()
20168 
 
20169 
  def validate(self):
20170 
    return
20171 
 
20172 
 
20173 
  def __repr__(self):
20174 
    L = ['%s=%r' % (key, value)
20175 
      for key, value in self.__dict__.iteritems()]
20176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20177 
 
20178 
  def __eq__(self, other):
20179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20180 
 
20181 
  def __ne__(self, other):
20182 
    return not (self == other)
20183 
 
4600 varun.gupt 20184 
class saveBluedartSettlements_args:
20185 
  """
20186 
  Attributes:
20187 
   - mapAWBAndAmount
20188 
  """
20189 
 
20190 
  thrift_spec = (
20191 
    None, # 0
20192 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
20193 
  )
20194 
 
20195 
  def __init__(self, mapAWBAndAmount=None,):
20196 
    self.mapAWBAndAmount = mapAWBAndAmount
20197 
 
20198 
  def read(self, iprot):
20199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20201 
      return
20202 
    iprot.readStructBegin()
20203 
    while True:
20204 
      (fname, ftype, fid) = iprot.readFieldBegin()
20205 
      if ftype == TType.STOP:
20206 
        break
20207 
      if fid == 1:
20208 
        if ftype == TType.MAP:
20209 
          self.mapAWBAndAmount = {}
5031 varun.gupt 20210 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
20211 
          for _i457 in xrange(_size453):
20212 
            _key458 = iprot.readI64();
20213 
            _val459 = iprot.readDouble();
20214 
            self.mapAWBAndAmount[_key458] = _val459
4600 varun.gupt 20215 
          iprot.readMapEnd()
20216 
        else:
20217 
          iprot.skip(ftype)
20218 
      else:
20219 
        iprot.skip(ftype)
20220 
      iprot.readFieldEnd()
20221 
    iprot.readStructEnd()
20222 
 
20223 
  def write(self, oprot):
20224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20226 
      return
20227 
    oprot.writeStructBegin('saveBluedartSettlements_args')
20228 
    if self.mapAWBAndAmount is not None:
20229 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
20230 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
5031 varun.gupt 20231 
      for kiter460,viter461 in self.mapAWBAndAmount.items():
20232 
        oprot.writeI64(kiter460)
20233 
        oprot.writeDouble(viter461)
4600 varun.gupt 20234 
      oprot.writeMapEnd()
20235 
      oprot.writeFieldEnd()
20236 
    oprot.writeFieldStop()
20237 
    oprot.writeStructEnd()
20238 
 
20239 
  def validate(self):
20240 
    return
20241 
 
20242 
 
20243 
  def __repr__(self):
20244 
    L = ['%s=%r' % (key, value)
20245 
      for key, value in self.__dict__.iteritems()]
20246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20247 
 
20248 
  def __eq__(self, other):
20249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20250 
 
20251 
  def __ne__(self, other):
20252 
    return not (self == other)
20253 
 
20254 
class saveBluedartSettlements_result:
20255 
  """
20256 
  Attributes:
20257 
   - ex
20258 
  """
20259 
 
20260 
  thrift_spec = (
20261 
    None, # 0
20262 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20263 
  )
20264 
 
20265 
  def __init__(self, ex=None,):
20266 
    self.ex = ex
20267 
 
20268 
  def read(self, iprot):
20269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20271 
      return
20272 
    iprot.readStructBegin()
20273 
    while True:
20274 
      (fname, ftype, fid) = iprot.readFieldBegin()
20275 
      if ftype == TType.STOP:
20276 
        break
20277 
      if fid == 1:
20278 
        if ftype == TType.STRUCT:
20279 
          self.ex = TransactionServiceException()
20280 
          self.ex.read(iprot)
20281 
        else:
20282 
          iprot.skip(ftype)
20283 
      else:
20284 
        iprot.skip(ftype)
20285 
      iprot.readFieldEnd()
20286 
    iprot.readStructEnd()
20287 
 
20288 
  def write(self, oprot):
20289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20291 
      return
20292 
    oprot.writeStructBegin('saveBluedartSettlements_result')
20293 
    if self.ex is not None:
20294 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20295 
      self.ex.write(oprot)
20296 
      oprot.writeFieldEnd()
20297 
    oprot.writeFieldStop()
20298 
    oprot.writeStructEnd()
20299 
 
20300 
  def validate(self):
20301 
    return
20302 
 
20303 
 
20304 
  def __repr__(self):
20305 
    L = ['%s=%r' % (key, value)
20306 
      for key, value in self.__dict__.iteritems()]
20307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20308 
 
20309 
  def __eq__(self, other):
20310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20311 
 
20312 
  def __ne__(self, other):
20313 
    return not (self == other)
20314 
 
20315 
class savePaymentSettlements_args:
20316 
  """
20317 
  Attributes:
20318 
   - settlementDate
20319 
   - paymentGatewayId
4905 varun.gupt 20320 
   - referenceId
4600 varun.gupt 20321 
   - serviceTax
20322 
   - otherCharges
20323 
   - netCollection
20324 
  """
20325 
 
20326 
  thrift_spec = (
20327 
    None, # 0
20328 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
20329 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 20330 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 20331 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
20332 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
20333 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
20334 
  )
20335 
 
4905 varun.gupt 20336 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 20337 
    self.settlementDate = settlementDate
20338 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 20339 
    self.referenceId = referenceId
4600 varun.gupt 20340 
    self.serviceTax = serviceTax
20341 
    self.otherCharges = otherCharges
20342 
    self.netCollection = netCollection
20343 
 
20344 
  def read(self, iprot):
20345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20347 
      return
20348 
    iprot.readStructBegin()
20349 
    while True:
20350 
      (fname, ftype, fid) = iprot.readFieldBegin()
20351 
      if ftype == TType.STOP:
20352 
        break
20353 
      if fid == 1:
20354 
        if ftype == TType.I64:
20355 
          self.settlementDate = iprot.readI64();
20356 
        else:
20357 
          iprot.skip(ftype)
20358 
      elif fid == 2:
20359 
        if ftype == TType.I64:
20360 
          self.paymentGatewayId = iprot.readI64();
20361 
        else:
20362 
          iprot.skip(ftype)
20363 
      elif fid == 3:
20364 
        if ftype == TType.I64:
4905 varun.gupt 20365 
          self.referenceId = iprot.readI64();
4600 varun.gupt 20366 
        else:
20367 
          iprot.skip(ftype)
20368 
      elif fid == 4:
20369 
        if ftype == TType.DOUBLE:
20370 
          self.serviceTax = iprot.readDouble();
20371 
        else:
20372 
          iprot.skip(ftype)
20373 
      elif fid == 5:
20374 
        if ftype == TType.DOUBLE:
20375 
          self.otherCharges = iprot.readDouble();
20376 
        else:
20377 
          iprot.skip(ftype)
20378 
      elif fid == 6:
20379 
        if ftype == TType.DOUBLE:
20380 
          self.netCollection = iprot.readDouble();
20381 
        else:
20382 
          iprot.skip(ftype)
20383 
      else:
20384 
        iprot.skip(ftype)
20385 
      iprot.readFieldEnd()
20386 
    iprot.readStructEnd()
20387 
 
20388 
  def write(self, oprot):
20389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20391 
      return
20392 
    oprot.writeStructBegin('savePaymentSettlements_args')
20393 
    if self.settlementDate is not None:
20394 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
20395 
      oprot.writeI64(self.settlementDate)
20396 
      oprot.writeFieldEnd()
20397 
    if self.paymentGatewayId is not None:
20398 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
20399 
      oprot.writeI64(self.paymentGatewayId)
20400 
      oprot.writeFieldEnd()
4905 varun.gupt 20401 
    if self.referenceId is not None:
20402 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
20403 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 20404 
      oprot.writeFieldEnd()
20405 
    if self.serviceTax is not None:
20406 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
20407 
      oprot.writeDouble(self.serviceTax)
20408 
      oprot.writeFieldEnd()
20409 
    if self.otherCharges is not None:
20410 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
20411 
      oprot.writeDouble(self.otherCharges)
20412 
      oprot.writeFieldEnd()
20413 
    if self.netCollection is not None:
20414 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
20415 
      oprot.writeDouble(self.netCollection)
20416 
      oprot.writeFieldEnd()
20417 
    oprot.writeFieldStop()
20418 
    oprot.writeStructEnd()
20419 
 
20420 
  def validate(self):
20421 
    return
20422 
 
20423 
 
20424 
  def __repr__(self):
20425 
    L = ['%s=%r' % (key, value)
20426 
      for key, value in self.__dict__.iteritems()]
20427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20428 
 
20429 
  def __eq__(self, other):
20430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20431 
 
20432 
  def __ne__(self, other):
20433 
    return not (self == other)
20434 
 
20435 
class savePaymentSettlements_result:
20436 
  """
20437 
  Attributes:
20438 
   - ex
20439 
  """
20440 
 
20441 
  thrift_spec = (
20442 
    None, # 0
20443 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20444 
  )
20445 
 
20446 
  def __init__(self, ex=None,):
20447 
    self.ex = ex
20448 
 
20449 
  def read(self, iprot):
20450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20452 
      return
20453 
    iprot.readStructBegin()
20454 
    while True:
20455 
      (fname, ftype, fid) = iprot.readFieldBegin()
20456 
      if ftype == TType.STOP:
20457 
        break
20458 
      if fid == 1:
20459 
        if ftype == TType.STRUCT:
20460 
          self.ex = TransactionServiceException()
20461 
          self.ex.read(iprot)
20462 
        else:
20463 
          iprot.skip(ftype)
20464 
      else:
20465 
        iprot.skip(ftype)
20466 
      iprot.readFieldEnd()
20467 
    iprot.readStructEnd()
20468 
 
20469 
  def write(self, oprot):
20470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20472 
      return
20473 
    oprot.writeStructBegin('savePaymentSettlements_result')
20474 
    if self.ex is not None:
20475 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20476 
      self.ex.write(oprot)
20477 
      oprot.writeFieldEnd()
20478 
    oprot.writeFieldStop()
20479 
    oprot.writeStructEnd()
20480 
 
20481 
  def validate(self):
20482 
    return
20483 
 
20484 
 
20485 
  def __repr__(self):
20486 
    L = ['%s=%r' % (key, value)
20487 
      for key, value in self.__dict__.iteritems()]
20488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20489 
 
20490 
  def __eq__(self, other):
20491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20492 
 
20493 
  def __ne__(self, other):
20494 
    return not (self == other)
20495 
 
20496 
class saveEBSSettlementSummary_args:
20497 
  """
20498 
  Attributes:
20499 
   - settlementId
20500 
   - settlementDate
20501 
   - transactionDateFrom
20502 
   - transactionDateTo
20503 
   - amount
20504 
  """
20505 
 
20506 
  thrift_spec = (
20507 
    None, # 0
20508 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20509 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
20510 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
20511 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
20512 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
20513 
  )
20514 
 
20515 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
20516 
    self.settlementId = settlementId
20517 
    self.settlementDate = settlementDate
20518 
    self.transactionDateFrom = transactionDateFrom
20519 
    self.transactionDateTo = transactionDateTo
20520 
    self.amount = amount
20521 
 
20522 
  def read(self, iprot):
20523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20525 
      return
20526 
    iprot.readStructBegin()
20527 
    while True:
20528 
      (fname, ftype, fid) = iprot.readFieldBegin()
20529 
      if ftype == TType.STOP:
20530 
        break
20531 
      if fid == 1:
20532 
        if ftype == TType.I64:
20533 
          self.settlementId = iprot.readI64();
20534 
        else:
20535 
          iprot.skip(ftype)
20536 
      elif fid == 2:
20537 
        if ftype == TType.I64:
20538 
          self.settlementDate = iprot.readI64();
20539 
        else:
20540 
          iprot.skip(ftype)
20541 
      elif fid == 3:
20542 
        if ftype == TType.I64:
20543 
          self.transactionDateFrom = iprot.readI64();
20544 
        else:
20545 
          iprot.skip(ftype)
20546 
      elif fid == 4:
20547 
        if ftype == TType.I64:
20548 
          self.transactionDateTo = iprot.readI64();
20549 
        else:
20550 
          iprot.skip(ftype)
20551 
      elif fid == 5:
20552 
        if ftype == TType.DOUBLE:
20553 
          self.amount = iprot.readDouble();
20554 
        else:
20555 
          iprot.skip(ftype)
20556 
      else:
20557 
        iprot.skip(ftype)
20558 
      iprot.readFieldEnd()
20559 
    iprot.readStructEnd()
20560 
 
20561 
  def write(self, oprot):
20562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20564 
      return
20565 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
20566 
    if self.settlementId is not None:
20567 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20568 
      oprot.writeI64(self.settlementId)
20569 
      oprot.writeFieldEnd()
20570 
    if self.settlementDate is not None:
20571 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
20572 
      oprot.writeI64(self.settlementDate)
20573 
      oprot.writeFieldEnd()
20574 
    if self.transactionDateFrom is not None:
20575 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
20576 
      oprot.writeI64(self.transactionDateFrom)
20577 
      oprot.writeFieldEnd()
20578 
    if self.transactionDateTo is not None:
20579 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
20580 
      oprot.writeI64(self.transactionDateTo)
20581 
      oprot.writeFieldEnd()
20582 
    if self.amount is not None:
20583 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
20584 
      oprot.writeDouble(self.amount)
20585 
      oprot.writeFieldEnd()
20586 
    oprot.writeFieldStop()
20587 
    oprot.writeStructEnd()
20588 
 
20589 
  def validate(self):
20590 
    return
20591 
 
20592 
 
20593 
  def __repr__(self):
20594 
    L = ['%s=%r' % (key, value)
20595 
      for key, value in self.__dict__.iteritems()]
20596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20597 
 
20598 
  def __eq__(self, other):
20599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20600 
 
20601 
  def __ne__(self, other):
20602 
    return not (self == other)
20603 
 
20604 
class saveEBSSettlementSummary_result:
20605 
  """
20606 
  Attributes:
20607 
   - ex
20608 
  """
20609 
 
20610 
  thrift_spec = (
20611 
    None, # 0
20612 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20613 
  )
20614 
 
20615 
  def __init__(self, ex=None,):
20616 
    self.ex = ex
20617 
 
20618 
  def read(self, iprot):
20619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20621 
      return
20622 
    iprot.readStructBegin()
20623 
    while True:
20624 
      (fname, ftype, fid) = iprot.readFieldBegin()
20625 
      if ftype == TType.STOP:
20626 
        break
20627 
      if fid == 1:
20628 
        if ftype == TType.STRUCT:
20629 
          self.ex = TransactionServiceException()
20630 
          self.ex.read(iprot)
20631 
        else:
20632 
          iprot.skip(ftype)
20633 
      else:
20634 
        iprot.skip(ftype)
20635 
      iprot.readFieldEnd()
20636 
    iprot.readStructEnd()
20637 
 
20638 
  def write(self, oprot):
20639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20641 
      return
20642 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
20643 
    if self.ex is not None:
20644 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20645 
      self.ex.write(oprot)
20646 
      oprot.writeFieldEnd()
20647 
    oprot.writeFieldStop()
20648 
    oprot.writeStructEnd()
20649 
 
20650 
  def validate(self):
20651 
    return
20652 
 
20653 
 
20654 
  def __repr__(self):
20655 
    L = ['%s=%r' % (key, value)
20656 
      for key, value in self.__dict__.iteritems()]
20657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20658 
 
20659 
  def __eq__(self, other):
20660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20661 
 
20662 
  def __ne__(self, other):
20663 
    return not (self == other)
20664 
 
5189 varun.gupt 20665 
class getSettlementForReferenceId_args:
4600 varun.gupt 20666 
  """
20667 
  Attributes:
5189 varun.gupt 20668 
   - referenceId
20669 
   - isRefund
4600 varun.gupt 20670 
  """
20671 
 
20672 
  thrift_spec = (
20673 
    None, # 0
5189 varun.gupt 20674 
    (1, TType.I64, 'referenceId', None, None, ), # 1
20675 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 20676 
  )
20677 
 
5189 varun.gupt 20678 
  def __init__(self, referenceId=None, isRefund=None,):
20679 
    self.referenceId = referenceId
20680 
    self.isRefund = isRefund
4600 varun.gupt 20681 
 
20682 
  def read(self, iprot):
20683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20685 
      return
20686 
    iprot.readStructBegin()
20687 
    while True:
20688 
      (fname, ftype, fid) = iprot.readFieldBegin()
20689 
      if ftype == TType.STOP:
20690 
        break
20691 
      if fid == 1:
20692 
        if ftype == TType.I64:
5189 varun.gupt 20693 
          self.referenceId = iprot.readI64();
4600 varun.gupt 20694 
        else:
20695 
          iprot.skip(ftype)
5189 varun.gupt 20696 
      elif fid == 2:
20697 
        if ftype == TType.BOOL:
20698 
          self.isRefund = iprot.readBool();
20699 
        else:
20700 
          iprot.skip(ftype)
4600 varun.gupt 20701 
      else:
20702 
        iprot.skip(ftype)
20703 
      iprot.readFieldEnd()
20704 
    iprot.readStructEnd()
20705 
 
20706 
  def write(self, oprot):
20707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20709 
      return
5189 varun.gupt 20710 
    oprot.writeStructBegin('getSettlementForReferenceId_args')
20711 
    if self.referenceId is not None:
20712 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
20713 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 20714 
      oprot.writeFieldEnd()
5189 varun.gupt 20715 
    if self.isRefund is not None:
20716 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
20717 
      oprot.writeBool(self.isRefund)
20718 
      oprot.writeFieldEnd()
4600 varun.gupt 20719 
    oprot.writeFieldStop()
20720 
    oprot.writeStructEnd()
20721 
 
20722 
  def validate(self):
20723 
    return
20724 
 
20725 
 
20726 
  def __repr__(self):
20727 
    L = ['%s=%r' % (key, value)
20728 
      for key, value in self.__dict__.iteritems()]
20729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20730 
 
20731 
  def __eq__(self, other):
20732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20733 
 
20734 
  def __ne__(self, other):
20735 
    return not (self == other)
20736 
 
5189 varun.gupt 20737 
class getSettlementForReferenceId_result:
4600 varun.gupt 20738 
  """
20739 
  Attributes:
20740 
   - success
20741 
   - ex
20742 
  """
20743 
 
20744 
  thrift_spec = (
20745 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
20746 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20747 
  )
20748 
 
20749 
  def __init__(self, success=None, ex=None,):
20750 
    self.success = success
20751 
    self.ex = ex
20752 
 
20753 
  def read(self, iprot):
20754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20756 
      return
20757 
    iprot.readStructBegin()
20758 
    while True:
20759 
      (fname, ftype, fid) = iprot.readFieldBegin()
20760 
      if ftype == TType.STOP:
20761 
        break
20762 
      if fid == 0:
20763 
        if ftype == TType.STRUCT:
20764 
          self.success = PaymentSettlement()
20765 
          self.success.read(iprot)
20766 
        else:
20767 
          iprot.skip(ftype)
20768 
      elif fid == 1:
20769 
        if ftype == TType.STRUCT:
20770 
          self.ex = TransactionServiceException()
20771 
          self.ex.read(iprot)
20772 
        else:
20773 
          iprot.skip(ftype)
20774 
      else:
20775 
        iprot.skip(ftype)
20776 
      iprot.readFieldEnd()
20777 
    iprot.readStructEnd()
20778 
 
20779 
  def write(self, oprot):
20780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20782 
      return
5189 varun.gupt 20783 
    oprot.writeStructBegin('getSettlementForReferenceId_result')
4600 varun.gupt 20784 
    if self.success is not None:
20785 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20786 
      self.success.write(oprot)
20787 
      oprot.writeFieldEnd()
20788 
    if self.ex is not None:
20789 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20790 
      self.ex.write(oprot)
20791 
      oprot.writeFieldEnd()
20792 
    oprot.writeFieldStop()
20793 
    oprot.writeStructEnd()
20794 
 
20795 
  def validate(self):
20796 
    return
20797 
 
20798 
 
20799 
  def __repr__(self):
20800 
    L = ['%s=%r' % (key, value)
20801 
      for key, value in self.__dict__.iteritems()]
20802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20803 
 
20804 
  def __eq__(self, other):
20805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20806 
 
20807 
  def __ne__(self, other):
20808 
    return not (self == other)
20809 
 
20810 
class getEBSSettlementSummaries_args:
20811 
 
20812 
  thrift_spec = (
20813 
  )
20814 
 
20815 
  def read(self, iprot):
20816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20818 
      return
20819 
    iprot.readStructBegin()
20820 
    while True:
20821 
      (fname, ftype, fid) = iprot.readFieldBegin()
20822 
      if ftype == TType.STOP:
20823 
        break
20824 
      else:
20825 
        iprot.skip(ftype)
20826 
      iprot.readFieldEnd()
20827 
    iprot.readStructEnd()
20828 
 
20829 
  def write(self, oprot):
20830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20832 
      return
20833 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
20834 
    oprot.writeFieldStop()
20835 
    oprot.writeStructEnd()
20836 
 
20837 
  def validate(self):
20838 
    return
20839 
 
20840 
 
20841 
  def __repr__(self):
20842 
    L = ['%s=%r' % (key, value)
20843 
      for key, value in self.__dict__.iteritems()]
20844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20845 
 
20846 
  def __eq__(self, other):
20847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20848 
 
20849 
  def __ne__(self, other):
20850 
    return not (self == other)
20851 
 
20852 
class getEBSSettlementSummaries_result:
20853 
  """
20854 
  Attributes:
20855 
   - success
20856 
   - ex
20857 
  """
20858 
 
20859 
  thrift_spec = (
20860 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
20861 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20862 
  )
20863 
 
20864 
  def __init__(self, success=None, ex=None,):
20865 
    self.success = success
20866 
    self.ex = ex
20867 
 
20868 
  def read(self, iprot):
20869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20871 
      return
20872 
    iprot.readStructBegin()
20873 
    while True:
20874 
      (fname, ftype, fid) = iprot.readFieldBegin()
20875 
      if ftype == TType.STOP:
20876 
        break
20877 
      if fid == 0:
20878 
        if ftype == TType.MAP:
20879 
          self.success = {}
5031 varun.gupt 20880 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20881 
          for _i466 in xrange(_size462):
20882 
            _key467 = iprot.readI64();
20883 
            _val468 = iprot.readString();
20884 
            self.success[_key467] = _val468
4600 varun.gupt 20885 
          iprot.readMapEnd()
20886 
        else:
20887 
          iprot.skip(ftype)
20888 
      elif fid == 1:
20889 
        if ftype == TType.STRUCT:
20890 
          self.ex = TransactionServiceException()
20891 
          self.ex.read(iprot)
20892 
        else:
20893 
          iprot.skip(ftype)
20894 
      else:
20895 
        iprot.skip(ftype)
20896 
      iprot.readFieldEnd()
20897 
    iprot.readStructEnd()
20898 
 
20899 
  def write(self, oprot):
20900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20902 
      return
20903 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
20904 
    if self.success is not None:
20905 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20906 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
5031 varun.gupt 20907 
      for kiter469,viter470 in self.success.items():
20908 
        oprot.writeI64(kiter469)
20909 
        oprot.writeString(viter470)
4600 varun.gupt 20910 
      oprot.writeMapEnd()
20911 
      oprot.writeFieldEnd()
20912 
    if self.ex is not None:
20913 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20914 
      self.ex.write(oprot)
20915 
      oprot.writeFieldEnd()
20916 
    oprot.writeFieldStop()
20917 
    oprot.writeStructEnd()
20918 
 
20919 
  def validate(self):
20920 
    return
20921 
 
20922 
 
20923 
  def __repr__(self):
20924 
    L = ['%s=%r' % (key, value)
20925 
      for key, value in self.__dict__.iteritems()]
20926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20927 
 
20928 
  def __eq__(self, other):
20929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20930 
 
20931 
  def __ne__(self, other):
20932 
    return not (self == other)
20933 
 
20934 
class markEBSSettlementUploaded_args:
20935 
  """
20936 
  Attributes:
20937 
   - settlementId
20938 
  """
20939 
 
20940 
  thrift_spec = (
20941 
    None, # 0
20942 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20943 
  )
20944 
 
20945 
  def __init__(self, settlementId=None,):
20946 
    self.settlementId = settlementId
20947 
 
20948 
  def read(self, iprot):
20949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20951 
      return
20952 
    iprot.readStructBegin()
20953 
    while True:
20954 
      (fname, ftype, fid) = iprot.readFieldBegin()
20955 
      if ftype == TType.STOP:
20956 
        break
20957 
      if fid == 1:
20958 
        if ftype == TType.I64:
20959 
          self.settlementId = iprot.readI64();
20960 
        else:
20961 
          iprot.skip(ftype)
20962 
      else:
20963 
        iprot.skip(ftype)
20964 
      iprot.readFieldEnd()
20965 
    iprot.readStructEnd()
20966 
 
20967 
  def write(self, oprot):
20968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20970 
      return
20971 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
20972 
    if self.settlementId is not None:
20973 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20974 
      oprot.writeI64(self.settlementId)
20975 
      oprot.writeFieldEnd()
20976 
    oprot.writeFieldStop()
20977 
    oprot.writeStructEnd()
20978 
 
20979 
  def validate(self):
20980 
    return
20981 
 
20982 
 
20983 
  def __repr__(self):
20984 
    L = ['%s=%r' % (key, value)
20985 
      for key, value in self.__dict__.iteritems()]
20986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20987 
 
20988 
  def __eq__(self, other):
20989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20990 
 
20991 
  def __ne__(self, other):
20992 
    return not (self == other)
20993 
 
20994 
class markEBSSettlementUploaded_result:
20995 
  """
20996 
  Attributes:
20997 
   - ex
20998 
  """
20999 
 
21000 
  thrift_spec = (
21001 
    None, # 0
21002 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21003 
  )
21004 
 
21005 
  def __init__(self, ex=None,):
21006 
    self.ex = ex
21007 
 
21008 
  def read(self, iprot):
21009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21011 
      return
21012 
    iprot.readStructBegin()
21013 
    while True:
21014 
      (fname, ftype, fid) = iprot.readFieldBegin()
21015 
      if ftype == TType.STOP:
21016 
        break
21017 
      if fid == 1:
21018 
        if ftype == TType.STRUCT:
21019 
          self.ex = TransactionServiceException()
21020 
          self.ex.read(iprot)
21021 
        else:
21022 
          iprot.skip(ftype)
21023 
      else:
21024 
        iprot.skip(ftype)
21025 
      iprot.readFieldEnd()
21026 
    iprot.readStructEnd()
21027 
 
21028 
  def write(self, oprot):
21029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21031 
      return
21032 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
21033 
    if self.ex is not None:
21034 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21035 
      self.ex.write(oprot)
21036 
      oprot.writeFieldEnd()
21037 
    oprot.writeFieldStop()
21038 
    oprot.writeStructEnd()
21039 
 
21040 
  def validate(self):
21041 
    return
21042 
 
21043 
 
21044 
  def __repr__(self):
21045 
    L = ['%s=%r' % (key, value)
21046 
      for key, value in self.__dict__.iteritems()]
21047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21048 
 
21049 
  def __eq__(self, other):
21050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21051 
 
21052 
  def __ne__(self, other):
21053 
    return not (self == other)
21054 
 
21055 
class getEBSSettlementDate_args:
21056 
  """
21057 
  Attributes:
21058 
   - settlementId
21059 
  """
21060 
 
21061 
  thrift_spec = (
21062 
    None, # 0
21063 
    (1, TType.I64, 'settlementId', None, None, ), # 1
21064 
  )
21065 
 
21066 
  def __init__(self, settlementId=None,):
21067 
    self.settlementId = settlementId
21068 
 
21069 
  def read(self, iprot):
21070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21072 
      return
21073 
    iprot.readStructBegin()
21074 
    while True:
21075 
      (fname, ftype, fid) = iprot.readFieldBegin()
21076 
      if ftype == TType.STOP:
21077 
        break
21078 
      if fid == 1:
21079 
        if ftype == TType.I64:
21080 
          self.settlementId = iprot.readI64();
21081 
        else:
21082 
          iprot.skip(ftype)
21083 
      else:
21084 
        iprot.skip(ftype)
21085 
      iprot.readFieldEnd()
21086 
    iprot.readStructEnd()
21087 
 
21088 
  def write(self, oprot):
21089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21091 
      return
21092 
    oprot.writeStructBegin('getEBSSettlementDate_args')
21093 
    if self.settlementId is not None:
21094 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
21095 
      oprot.writeI64(self.settlementId)
21096 
      oprot.writeFieldEnd()
21097 
    oprot.writeFieldStop()
21098 
    oprot.writeStructEnd()
21099 
 
21100 
  def validate(self):
21101 
    return
21102 
 
21103 
 
21104 
  def __repr__(self):
21105 
    L = ['%s=%r' % (key, value)
21106 
      for key, value in self.__dict__.iteritems()]
21107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21108 
 
21109 
  def __eq__(self, other):
21110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21111 
 
21112 
  def __ne__(self, other):
21113 
    return not (self == other)
21114 
 
21115 
class getEBSSettlementDate_result:
21116 
  """
21117 
  Attributes:
21118 
   - success
21119 
   - ex
21120 
  """
21121 
 
21122 
  thrift_spec = (
21123 
    (0, TType.I64, 'success', None, None, ), # 0
21124 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21125 
  )
21126 
 
21127 
  def __init__(self, success=None, ex=None,):
21128 
    self.success = success
21129 
    self.ex = ex
21130 
 
21131 
  def read(self, iprot):
21132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21134 
      return
21135 
    iprot.readStructBegin()
21136 
    while True:
21137 
      (fname, ftype, fid) = iprot.readFieldBegin()
21138 
      if ftype == TType.STOP:
21139 
        break
21140 
      if fid == 0:
21141 
        if ftype == TType.I64:
21142 
          self.success = iprot.readI64();
21143 
        else:
21144 
          iprot.skip(ftype)
21145 
      elif fid == 1:
21146 
        if ftype == TType.STRUCT:
21147 
          self.ex = TransactionServiceException()
21148 
          self.ex.read(iprot)
21149 
        else:
21150 
          iprot.skip(ftype)
21151 
      else:
21152 
        iprot.skip(ftype)
21153 
      iprot.readFieldEnd()
21154 
    iprot.readStructEnd()
21155 
 
21156 
  def write(self, oprot):
21157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21159 
      return
21160 
    oprot.writeStructBegin('getEBSSettlementDate_result')
21161 
    if self.success is not None:
21162 
      oprot.writeFieldBegin('success', TType.I64, 0)
21163 
      oprot.writeI64(self.success)
21164 
      oprot.writeFieldEnd()
21165 
    if self.ex is not None:
21166 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21167 
      self.ex.write(oprot)
21168 
      oprot.writeFieldEnd()
21169 
    oprot.writeFieldStop()
21170 
    oprot.writeStructEnd()
21171 
 
21172 
  def validate(self):
21173 
    return
21174 
 
21175 
 
21176 
  def __repr__(self):
21177 
    L = ['%s=%r' % (key, value)
21178 
      for key, value in self.__dict__.iteritems()]
21179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21180 
 
21181 
  def __eq__(self, other):
21182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21183 
 
21184 
  def __ne__(self, other):
21185 
    return not (self == other)
4715 varun.gupt 21186 
 
21187 
class getSettlementsByDate_args:
21188 
  """
21189 
  Attributes:
21190 
   - settlementDateFrom
21191 
   - settlementDateTo
21192 
   - isRefund
21193 
  """
21194 
 
21195 
  thrift_spec = (
21196 
    None, # 0
21197 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
21198 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
21199 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
21200 
  )
21201 
 
21202 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
21203 
    self.settlementDateFrom = settlementDateFrom
21204 
    self.settlementDateTo = settlementDateTo
21205 
    self.isRefund = isRefund
21206 
 
21207 
  def read(self, iprot):
21208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21210 
      return
21211 
    iprot.readStructBegin()
21212 
    while True:
21213 
      (fname, ftype, fid) = iprot.readFieldBegin()
21214 
      if ftype == TType.STOP:
21215 
        break
21216 
      if fid == 1:
21217 
        if ftype == TType.I64:
21218 
          self.settlementDateFrom = iprot.readI64();
21219 
        else:
21220 
          iprot.skip(ftype)
21221 
      elif fid == 2:
21222 
        if ftype == TType.I64:
21223 
          self.settlementDateTo = iprot.readI64();
21224 
        else:
21225 
          iprot.skip(ftype)
21226 
      elif fid == 3:
21227 
        if ftype == TType.BOOL:
21228 
          self.isRefund = iprot.readBool();
21229 
        else:
21230 
          iprot.skip(ftype)
21231 
      else:
21232 
        iprot.skip(ftype)
21233 
      iprot.readFieldEnd()
21234 
    iprot.readStructEnd()
21235 
 
21236 
  def write(self, oprot):
21237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21239 
      return
21240 
    oprot.writeStructBegin('getSettlementsByDate_args')
21241 
    if self.settlementDateFrom is not None:
21242 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
21243 
      oprot.writeI64(self.settlementDateFrom)
21244 
      oprot.writeFieldEnd()
21245 
    if self.settlementDateTo is not None:
21246 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
21247 
      oprot.writeI64(self.settlementDateTo)
21248 
      oprot.writeFieldEnd()
21249 
    if self.isRefund is not None:
21250 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
21251 
      oprot.writeBool(self.isRefund)
21252 
      oprot.writeFieldEnd()
21253 
    oprot.writeFieldStop()
21254 
    oprot.writeStructEnd()
21255 
 
21256 
  def validate(self):
21257 
    return
21258 
 
21259 
 
21260 
  def __repr__(self):
21261 
    L = ['%s=%r' % (key, value)
21262 
      for key, value in self.__dict__.iteritems()]
21263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21264 
 
21265 
  def __eq__(self, other):
21266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21267 
 
21268 
  def __ne__(self, other):
21269 
    return not (self == other)
21270 
 
21271 
class getSettlementsByDate_result:
21272 
  """
21273 
  Attributes:
21274 
   - success
21275 
   - ex
21276 
  """
21277 
 
21278 
  thrift_spec = (
21279 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
21280 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21281 
  )
21282 
 
21283 
  def __init__(self, success=None, ex=None,):
21284 
    self.success = success
21285 
    self.ex = ex
21286 
 
21287 
  def read(self, iprot):
21288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21290 
      return
21291 
    iprot.readStructBegin()
21292 
    while True:
21293 
      (fname, ftype, fid) = iprot.readFieldBegin()
21294 
      if ftype == TType.STOP:
21295 
        break
21296 
      if fid == 0:
21297 
        if ftype == TType.LIST:
21298 
          self.success = []
5031 varun.gupt 21299 
          (_etype474, _size471) = iprot.readListBegin()
21300 
          for _i475 in xrange(_size471):
21301 
            _elem476 = PaymentSettlement()
21302 
            _elem476.read(iprot)
21303 
            self.success.append(_elem476)
4715 varun.gupt 21304 
          iprot.readListEnd()
21305 
        else:
21306 
          iprot.skip(ftype)
21307 
      elif fid == 1:
21308 
        if ftype == TType.STRUCT:
21309 
          self.ex = TransactionServiceException()
21310 
          self.ex.read(iprot)
21311 
        else:
21312 
          iprot.skip(ftype)
21313 
      else:
21314 
        iprot.skip(ftype)
21315 
      iprot.readFieldEnd()
21316 
    iprot.readStructEnd()
21317 
 
21318 
  def write(self, oprot):
21319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21321 
      return
21322 
    oprot.writeStructBegin('getSettlementsByDate_result')
21323 
    if self.success is not None:
21324 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21325 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 21326 
      for iter477 in self.success:
21327 
        iter477.write(oprot)
4715 varun.gupt 21328 
      oprot.writeListEnd()
21329 
      oprot.writeFieldEnd()
21330 
    if self.ex is not None:
21331 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21332 
      self.ex.write(oprot)
21333 
      oprot.writeFieldEnd()
21334 
    oprot.writeFieldStop()
21335 
    oprot.writeStructEnd()
21336 
 
21337 
  def validate(self):
21338 
    return
21339 
 
21340 
 
21341 
  def __repr__(self):
21342 
    L = ['%s=%r' % (key, value)
21343 
      for key, value in self.__dict__.iteritems()]
21344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21345 
 
21346 
  def __eq__(self, other):
21347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21348 
 
21349 
  def __ne__(self, other):
21350 
    return not (self == other)
21351 
 
21352 
class getReshippedOrderIds_args:
21353 
  """
21354 
  Attributes:
21355 
   - orderIds
21356 
  """
21357 
 
21358 
  thrift_spec = (
21359 
    None, # 0
21360 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
21361 
  )
21362 
 
21363 
  def __init__(self, orderIds=None,):
21364 
    self.orderIds = orderIds
21365 
 
21366 
  def read(self, iprot):
21367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21369 
      return
21370 
    iprot.readStructBegin()
21371 
    while True:
21372 
      (fname, ftype, fid) = iprot.readFieldBegin()
21373 
      if ftype == TType.STOP:
21374 
        break
21375 
      if fid == 1:
21376 
        if ftype == TType.LIST:
21377 
          self.orderIds = []
5031 varun.gupt 21378 
          (_etype481, _size478) = iprot.readListBegin()
21379 
          for _i482 in xrange(_size478):
21380 
            _elem483 = iprot.readI64();
21381 
            self.orderIds.append(_elem483)
4715 varun.gupt 21382 
          iprot.readListEnd()
21383 
        else:
21384 
          iprot.skip(ftype)
21385 
      else:
21386 
        iprot.skip(ftype)
21387 
      iprot.readFieldEnd()
21388 
    iprot.readStructEnd()
21389 
 
21390 
  def write(self, oprot):
21391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21393 
      return
21394 
    oprot.writeStructBegin('getReshippedOrderIds_args')
21395 
    if self.orderIds is not None:
21396 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
21397 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5031 varun.gupt 21398 
      for iter484 in self.orderIds:
21399 
        oprot.writeI64(iter484)
4715 varun.gupt 21400 
      oprot.writeListEnd()
21401 
      oprot.writeFieldEnd()
21402 
    oprot.writeFieldStop()
21403 
    oprot.writeStructEnd()
21404 
 
21405 
  def validate(self):
21406 
    return
21407 
 
21408 
 
21409 
  def __repr__(self):
21410 
    L = ['%s=%r' % (key, value)
21411 
      for key, value in self.__dict__.iteritems()]
21412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21413 
 
21414 
  def __eq__(self, other):
21415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21416 
 
21417 
  def __ne__(self, other):
21418 
    return not (self == other)
21419 
 
21420 
class getReshippedOrderIds_result:
21421 
  """
21422 
  Attributes:
21423 
   - success
21424 
   - ex
21425 
  """
21426 
 
21427 
  thrift_spec = (
21428 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21429 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21430 
  )
21431 
 
21432 
  def __init__(self, success=None, ex=None,):
21433 
    self.success = success
21434 
    self.ex = ex
21435 
 
21436 
  def read(self, iprot):
21437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21439 
      return
21440 
    iprot.readStructBegin()
21441 
    while True:
21442 
      (fname, ftype, fid) = iprot.readFieldBegin()
21443 
      if ftype == TType.STOP:
21444 
        break
21445 
      if fid == 0:
21446 
        if ftype == TType.LIST:
21447 
          self.success = []
5031 varun.gupt 21448 
          (_etype488, _size485) = iprot.readListBegin()
21449 
          for _i489 in xrange(_size485):
21450 
            _elem490 = iprot.readI64();
21451 
            self.success.append(_elem490)
4715 varun.gupt 21452 
          iprot.readListEnd()
21453 
        else:
21454 
          iprot.skip(ftype)
21455 
      elif fid == 1:
21456 
        if ftype == TType.STRUCT:
21457 
          self.ex = TransactionServiceException()
21458 
          self.ex.read(iprot)
21459 
        else:
21460 
          iprot.skip(ftype)
21461 
      else:
21462 
        iprot.skip(ftype)
21463 
      iprot.readFieldEnd()
21464 
    iprot.readStructEnd()
21465 
 
21466 
  def write(self, oprot):
21467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21469 
      return
21470 
    oprot.writeStructBegin('getReshippedOrderIds_result')
21471 
    if self.success is not None:
21472 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21473 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 21474 
      for iter491 in self.success:
21475 
        oprot.writeI64(iter491)
4715 varun.gupt 21476 
      oprot.writeListEnd()
21477 
      oprot.writeFieldEnd()
21478 
    if self.ex is not None:
21479 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21480 
      self.ex.write(oprot)
21481 
      oprot.writeFieldEnd()
21482 
    oprot.writeFieldStop()
21483 
    oprot.writeStructEnd()
21484 
 
21485 
  def validate(self):
21486 
    return
21487 
 
21488 
 
21489 
  def __repr__(self):
21490 
    L = ['%s=%r' % (key, value)
21491 
      for key, value in self.__dict__.iteritems()]
21492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21493 
 
21494 
  def __eq__(self, other):
21495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21496 
 
21497 
  def __ne__(self, other):
21498 
    return not (self == other)
4757 mandeep.dh 21499 
 
5348 anupam.sin 21500 
class updateOrdersAsPORaised_args:
21501 
  """
21502 
  Attributes:
21503 
   - itemIdQuantityMap
21504 
   - purchaseOrderId
21505 
   - warehouseId
21506 
  """
21507 
 
21508 
  thrift_spec = (
21509 
    None, # 0
21510 
    (1, TType.MAP, 'itemIdQuantityMap', (TType.I64,None,TType.I64,None), None, ), # 1
21511 
    (2, TType.I64, 'purchaseOrderId', None, None, ), # 2
21512 
    (3, TType.I64, 'warehouseId', None, None, ), # 3
21513 
  )
21514 
 
21515 
  def __init__(self, itemIdQuantityMap=None, purchaseOrderId=None, warehouseId=None,):
21516 
    self.itemIdQuantityMap = itemIdQuantityMap
21517 
    self.purchaseOrderId = purchaseOrderId
21518 
    self.warehouseId = warehouseId
21519 
 
21520 
  def read(self, iprot):
21521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21523 
      return
21524 
    iprot.readStructBegin()
21525 
    while True:
21526 
      (fname, ftype, fid) = iprot.readFieldBegin()
21527 
      if ftype == TType.STOP:
21528 
        break
21529 
      if fid == 1:
21530 
        if ftype == TType.MAP:
21531 
          self.itemIdQuantityMap = {}
21532 
          (_ktype493, _vtype494, _size492 ) = iprot.readMapBegin()
21533 
          for _i496 in xrange(_size492):
21534 
            _key497 = iprot.readI64();
21535 
            _val498 = iprot.readI64();
21536 
            self.itemIdQuantityMap[_key497] = _val498
21537 
          iprot.readMapEnd()
21538 
        else:
21539 
          iprot.skip(ftype)
21540 
      elif fid == 2:
21541 
        if ftype == TType.I64:
21542 
          self.purchaseOrderId = iprot.readI64();
21543 
        else:
21544 
          iprot.skip(ftype)
21545 
      elif fid == 3:
21546 
        if ftype == TType.I64:
21547 
          self.warehouseId = iprot.readI64();
21548 
        else:
21549 
          iprot.skip(ftype)
21550 
      else:
21551 
        iprot.skip(ftype)
21552 
      iprot.readFieldEnd()
21553 
    iprot.readStructEnd()
21554 
 
21555 
  def write(self, oprot):
21556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21558 
      return
21559 
    oprot.writeStructBegin('updateOrdersAsPORaised_args')
21560 
    if self.itemIdQuantityMap is not None:
21561 
      oprot.writeFieldBegin('itemIdQuantityMap', TType.MAP, 1)
21562 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemIdQuantityMap))
21563 
      for kiter499,viter500 in self.itemIdQuantityMap.items():
21564 
        oprot.writeI64(kiter499)
21565 
        oprot.writeI64(viter500)
21566 
      oprot.writeMapEnd()
21567 
      oprot.writeFieldEnd()
21568 
    if self.purchaseOrderId is not None:
21569 
      oprot.writeFieldBegin('purchaseOrderId', TType.I64, 2)
21570 
      oprot.writeI64(self.purchaseOrderId)
21571 
      oprot.writeFieldEnd()
21572 
    if self.warehouseId is not None:
21573 
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
21574 
      oprot.writeI64(self.warehouseId)
21575 
      oprot.writeFieldEnd()
21576 
    oprot.writeFieldStop()
21577 
    oprot.writeStructEnd()
21578 
 
21579 
  def validate(self):
21580 
    return
21581 
 
21582 
 
21583 
  def __repr__(self):
21584 
    L = ['%s=%r' % (key, value)
21585 
      for key, value in self.__dict__.iteritems()]
21586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21587 
 
21588 
  def __eq__(self, other):
21589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21590 
 
21591 
  def __ne__(self, other):
21592 
    return not (self == other)
21593 
 
21594 
class updateOrdersAsPORaised_result:
21595 
  """
21596 
  Attributes:
21597 
   - ex
21598 
  """
21599 
 
21600 
  thrift_spec = (
21601 
    None, # 0
21602 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21603 
  )
21604 
 
21605 
  def __init__(self, ex=None,):
21606 
    self.ex = ex
21607 
 
21608 
  def read(self, iprot):
21609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21611 
      return
21612 
    iprot.readStructBegin()
21613 
    while True:
21614 
      (fname, ftype, fid) = iprot.readFieldBegin()
21615 
      if ftype == TType.STOP:
21616 
        break
21617 
      if fid == 1:
21618 
        if ftype == TType.STRUCT:
21619 
          self.ex = TransactionServiceException()
21620 
          self.ex.read(iprot)
21621 
        else:
21622 
          iprot.skip(ftype)
21623 
      else:
21624 
        iprot.skip(ftype)
21625 
      iprot.readFieldEnd()
21626 
    iprot.readStructEnd()
21627 
 
21628 
  def write(self, oprot):
21629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21631 
      return
21632 
    oprot.writeStructBegin('updateOrdersAsPORaised_result')
21633 
    if self.ex is not None:
21634 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21635 
      self.ex.write(oprot)
21636 
      oprot.writeFieldEnd()
21637 
    oprot.writeFieldStop()
21638 
    oprot.writeStructEnd()
21639 
 
21640 
  def validate(self):
21641 
    return
21642 
 
21643 
 
21644 
  def __repr__(self):
21645 
    L = ['%s=%r' % (key, value)
21646 
      for key, value in self.__dict__.iteritems()]
21647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21648 
 
21649 
  def __eq__(self, other):
21650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21651 
 
21652 
  def __ne__(self, other):
21653 
    return not (self == other)
21654 
 
4875 varun.gupt 21655 
class getOrdersWhereVendorNotPaid_args:
21656 
  """
21657 
  Attributes:
21658 
   - vendorId
21659 
  """
21660 
 
21661 
  thrift_spec = (
21662 
    None, # 0
21663 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21664 
  )
21665 
 
21666 
  def __init__(self, vendorId=None,):
21667 
    self.vendorId = vendorId
21668 
 
21669 
  def read(self, iprot):
21670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21672 
      return
21673 
    iprot.readStructBegin()
21674 
    while True:
21675 
      (fname, ftype, fid) = iprot.readFieldBegin()
21676 
      if ftype == TType.STOP:
21677 
        break
21678 
      if fid == 1:
21679 
        if ftype == TType.I64:
21680 
          self.vendorId = iprot.readI64();
21681 
        else:
21682 
          iprot.skip(ftype)
21683 
      else:
21684 
        iprot.skip(ftype)
21685 
      iprot.readFieldEnd()
21686 
    iprot.readStructEnd()
21687 
 
21688 
  def write(self, oprot):
21689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21691 
      return
21692 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_args')
21693 
    if self.vendorId is not None:
21694 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21695 
      oprot.writeI64(self.vendorId)
21696 
      oprot.writeFieldEnd()
21697 
    oprot.writeFieldStop()
21698 
    oprot.writeStructEnd()
21699 
 
21700 
  def validate(self):
21701 
    return
21702 
 
21703 
 
21704 
  def __repr__(self):
21705 
    L = ['%s=%r' % (key, value)
21706 
      for key, value in self.__dict__.iteritems()]
21707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21708 
 
21709 
  def __eq__(self, other):
21710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21711 
 
21712 
  def __ne__(self, other):
21713 
    return not (self == other)
21714 
 
21715 
class getOrdersWhereVendorNotPaid_result:
21716 
  """
21717 
  Attributes:
21718 
   - success
21719 
   - ex
21720 
  """
21721 
 
21722 
  thrift_spec = (
21723 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21724 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21725 
  )
21726 
 
21727 
  def __init__(self, success=None, ex=None,):
21728 
    self.success = success
21729 
    self.ex = ex
21730 
 
21731 
  def read(self, iprot):
21732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21734 
      return
21735 
    iprot.readStructBegin()
21736 
    while True:
21737 
      (fname, ftype, fid) = iprot.readFieldBegin()
21738 
      if ftype == TType.STOP:
21739 
        break
21740 
      if fid == 0:
21741 
        if ftype == TType.LIST:
21742 
          self.success = []
5348 anupam.sin 21743 
          (_etype504, _size501) = iprot.readListBegin()
21744 
          for _i505 in xrange(_size501):
21745 
            _elem506 = Order()
21746 
            _elem506.read(iprot)
21747 
            self.success.append(_elem506)
4875 varun.gupt 21748 
          iprot.readListEnd()
21749 
        else:
21750 
          iprot.skip(ftype)
21751 
      elif fid == 1:
21752 
        if ftype == TType.STRUCT:
21753 
          self.ex = TransactionServiceException()
21754 
          self.ex.read(iprot)
21755 
        else:
21756 
          iprot.skip(ftype)
21757 
      else:
21758 
        iprot.skip(ftype)
21759 
      iprot.readFieldEnd()
21760 
    iprot.readStructEnd()
21761 
 
21762 
  def write(self, oprot):
21763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21765 
      return
21766 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_result')
21767 
    if self.success is not None:
21768 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21769 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5348 anupam.sin 21770 
      for iter507 in self.success:
21771 
        iter507.write(oprot)
4875 varun.gupt 21772 
      oprot.writeListEnd()
21773 
      oprot.writeFieldEnd()
21774 
    if self.ex is not None:
21775 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21776 
      self.ex.write(oprot)
21777 
      oprot.writeFieldEnd()
21778 
    oprot.writeFieldStop()
21779 
    oprot.writeStructEnd()
21780 
 
21781 
  def validate(self):
21782 
    return
21783 
 
21784 
 
21785 
  def __repr__(self):
21786 
    L = ['%s=%r' % (key, value)
21787 
      for key, value in self.__dict__.iteritems()]
21788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21789 
 
21790 
  def __eq__(self, other):
21791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21792 
 
21793 
  def __ne__(self, other):
21794 
    return not (self == other)
5031 varun.gupt 21795 
 
21796 
class getStatusDistributionOfOrders_args:
21797 
  """
21798 
  Attributes:
21799 
   - startDate
21800 
   - endDate
21801 
  """
21802 
 
21803 
  thrift_spec = (
21804 
    None, # 0
21805 
    (1, TType.I64, 'startDate', None, None, ), # 1
21806 
    (2, TType.I64, 'endDate', None, None, ), # 2
21807 
  )
21808 
 
21809 
  def __init__(self, startDate=None, endDate=None,):
21810 
    self.startDate = startDate
21811 
    self.endDate = endDate
21812 
 
21813 
  def read(self, iprot):
21814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21816 
      return
21817 
    iprot.readStructBegin()
21818 
    while True:
21819 
      (fname, ftype, fid) = iprot.readFieldBegin()
21820 
      if ftype == TType.STOP:
21821 
        break
21822 
      if fid == 1:
21823 
        if ftype == TType.I64:
21824 
          self.startDate = iprot.readI64();
21825 
        else:
21826 
          iprot.skip(ftype)
21827 
      elif fid == 2:
21828 
        if ftype == TType.I64:
21829 
          self.endDate = iprot.readI64();
21830 
        else:
21831 
          iprot.skip(ftype)
21832 
      else:
21833 
        iprot.skip(ftype)
21834 
      iprot.readFieldEnd()
21835 
    iprot.readStructEnd()
21836 
 
21837 
  def write(self, oprot):
21838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21840 
      return
21841 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
21842 
    if self.startDate is not None:
21843 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
21844 
      oprot.writeI64(self.startDate)
21845 
      oprot.writeFieldEnd()
21846 
    if self.endDate is not None:
21847 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
21848 
      oprot.writeI64(self.endDate)
21849 
      oprot.writeFieldEnd()
21850 
    oprot.writeFieldStop()
21851 
    oprot.writeStructEnd()
21852 
 
21853 
  def validate(self):
21854 
    return
21855 
 
21856 
 
21857 
  def __repr__(self):
21858 
    L = ['%s=%r' % (key, value)
21859 
      for key, value in self.__dict__.iteritems()]
21860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21861 
 
21862 
  def __eq__(self, other):
21863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21864 
 
21865 
  def __ne__(self, other):
21866 
    return not (self == other)
21867 
 
21868 
class getStatusDistributionOfOrders_result:
21869 
  """
21870 
  Attributes:
21871 
   - success
21872 
   - ex
21873 
  """
21874 
 
21875 
  thrift_spec = (
21876 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
21877 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21878 
  )
21879 
 
21880 
  def __init__(self, success=None, ex=None,):
21881 
    self.success = success
21882 
    self.ex = ex
21883 
 
21884 
  def read(self, iprot):
21885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21887 
      return
21888 
    iprot.readStructBegin()
21889 
    while True:
21890 
      (fname, ftype, fid) = iprot.readFieldBegin()
21891 
      if ftype == TType.STOP:
21892 
        break
21893 
      if fid == 0:
21894 
        if ftype == TType.MAP:
21895 
          self.success = {}
5348 anupam.sin 21896 
          (_ktype509, _vtype510, _size508 ) = iprot.readMapBegin()
21897 
          for _i512 in xrange(_size508):
21898 
            _key513 = iprot.readI64();
21899 
            _val514 = iprot.readI64();
21900 
            self.success[_key513] = _val514
5031 varun.gupt 21901 
          iprot.readMapEnd()
21902 
        else:
21903 
          iprot.skip(ftype)
21904 
      elif fid == 1:
21905 
        if ftype == TType.STRUCT:
21906 
          self.ex = TransactionServiceException()
21907 
          self.ex.read(iprot)
21908 
        else:
21909 
          iprot.skip(ftype)
21910 
      else:
21911 
        iprot.skip(ftype)
21912 
      iprot.readFieldEnd()
21913 
    iprot.readStructEnd()
21914 
 
21915 
  def write(self, oprot):
21916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21918 
      return
21919 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
21920 
    if self.success is not None:
21921 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21922 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5348 anupam.sin 21923 
      for kiter515,viter516 in self.success.items():
21924 
        oprot.writeI64(kiter515)
21925 
        oprot.writeI64(viter516)
5031 varun.gupt 21926 
      oprot.writeMapEnd()
21927 
      oprot.writeFieldEnd()
21928 
    if self.ex is not None:
21929 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21930 
      self.ex.write(oprot)
21931 
      oprot.writeFieldEnd()
21932 
    oprot.writeFieldStop()
21933 
    oprot.writeStructEnd()
21934 
 
21935 
  def validate(self):
21936 
    return
21937 
 
21938 
 
21939 
  def __repr__(self):
21940 
    L = ['%s=%r' % (key, value)
21941 
      for key, value in self.__dict__.iteritems()]
21942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21943 
 
21944 
  def __eq__(self, other):
21945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21946 
 
21947 
  def __ne__(self, other):
21948 
    return not (self == other)
5067 varun.gupt 21949 
 
21950 
class getOrderIdsForStatus_args:
21951 
  """
21952 
  Attributes:
21953 
   - status
21954 
   - startDatetime
21955 
   - endDatetime
21956 
  """
21957 
 
21958 
  thrift_spec = (
21959 
    None, # 0
21960 
    (1, TType.I64, 'status', None, None, ), # 1
21961 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
21962 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
21963 
  )
21964 
 
21965 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
21966 
    self.status = status
21967 
    self.startDatetime = startDatetime
21968 
    self.endDatetime = endDatetime
21969 
 
21970 
  def read(self, iprot):
21971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21973 
      return
21974 
    iprot.readStructBegin()
21975 
    while True:
21976 
      (fname, ftype, fid) = iprot.readFieldBegin()
21977 
      if ftype == TType.STOP:
21978 
        break
21979 
      if fid == 1:
21980 
        if ftype == TType.I64:
21981 
          self.status = iprot.readI64();
21982 
        else:
21983 
          iprot.skip(ftype)
21984 
      elif fid == 2:
21985 
        if ftype == TType.I64:
21986 
          self.startDatetime = iprot.readI64();
21987 
        else:
21988 
          iprot.skip(ftype)
21989 
      elif fid == 3:
21990 
        if ftype == TType.I64:
21991 
          self.endDatetime = iprot.readI64();
21992 
        else:
21993 
          iprot.skip(ftype)
21994 
      else:
21995 
        iprot.skip(ftype)
21996 
      iprot.readFieldEnd()
21997 
    iprot.readStructEnd()
21998 
 
21999 
  def write(self, oprot):
22000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22002 
      return
22003 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
22004 
    if self.status is not None:
22005 
      oprot.writeFieldBegin('status', TType.I64, 1)
22006 
      oprot.writeI64(self.status)
22007 
      oprot.writeFieldEnd()
22008 
    if self.startDatetime is not None:
22009 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
22010 
      oprot.writeI64(self.startDatetime)
22011 
      oprot.writeFieldEnd()
22012 
    if self.endDatetime is not None:
22013 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
22014 
      oprot.writeI64(self.endDatetime)
22015 
      oprot.writeFieldEnd()
22016 
    oprot.writeFieldStop()
22017 
    oprot.writeStructEnd()
22018 
 
22019 
  def validate(self):
22020 
    return
22021 
 
22022 
 
22023 
  def __repr__(self):
22024 
    L = ['%s=%r' % (key, value)
22025 
      for key, value in self.__dict__.iteritems()]
22026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22027 
 
22028 
  def __eq__(self, other):
22029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22030 
 
22031 
  def __ne__(self, other):
22032 
    return not (self == other)
22033 
 
22034 
class getOrderIdsForStatus_result:
22035 
  """
22036 
  Attributes:
22037 
   - success
22038 
   - ex
22039 
  """
22040 
 
22041 
  thrift_spec = (
22042 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
22043 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22044 
  )
22045 
 
22046 
  def __init__(self, success=None, ex=None,):
22047 
    self.success = success
22048 
    self.ex = ex
22049 
 
22050 
  def read(self, iprot):
22051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22053 
      return
22054 
    iprot.readStructBegin()
22055 
    while True:
22056 
      (fname, ftype, fid) = iprot.readFieldBegin()
22057 
      if ftype == TType.STOP:
22058 
        break
22059 
      if fid == 0:
22060 
        if ftype == TType.LIST:
22061 
          self.success = []
5348 anupam.sin 22062 
          (_etype520, _size517) = iprot.readListBegin()
22063 
          for _i521 in xrange(_size517):
22064 
            _elem522 = iprot.readI64();
22065 
            self.success.append(_elem522)
5067 varun.gupt 22066 
          iprot.readListEnd()
22067 
        else:
22068 
          iprot.skip(ftype)
22069 
      elif fid == 1:
22070 
        if ftype == TType.STRUCT:
22071 
          self.ex = TransactionServiceException()
22072 
          self.ex.read(iprot)
22073 
        else:
22074 
          iprot.skip(ftype)
22075 
      else:
22076 
        iprot.skip(ftype)
22077 
      iprot.readFieldEnd()
22078 
    iprot.readStructEnd()
22079 
 
22080 
  def write(self, oprot):
22081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22083 
      return
22084 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
22085 
    if self.success is not None:
22086 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22087 
      oprot.writeListBegin(TType.I64, len(self.success))
5348 anupam.sin 22088 
      for iter523 in self.success:
22089 
        oprot.writeI64(iter523)
5067 varun.gupt 22090 
      oprot.writeListEnd()
22091 
      oprot.writeFieldEnd()
22092 
    if self.ex is not None:
22093 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22094 
      self.ex.write(oprot)
22095 
      oprot.writeFieldEnd()
22096 
    oprot.writeFieldStop()
22097 
    oprot.writeStructEnd()
22098 
 
22099 
  def validate(self):
22100 
    return
22101 
 
22102 
 
22103 
  def __repr__(self):
22104 
    L = ['%s=%r' % (key, value)
22105 
      for key, value in self.__dict__.iteritems()]
22106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22107 
 
22108 
  def __eq__(self, other):
22109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22110 
 
22111 
  def __ne__(self, other):
22112 
    return not (self == other)
5099 varun.gupt 22113 
 
5348 anupam.sin 22114 
class updateCODAgent_args:
22115 
  """
22116 
  Attributes:
22117 
   - agent
22118 
   - orderId
22119 
  """
22120 
 
22121 
  thrift_spec = (
22122 
    None, # 0
22123 
    (1, TType.STRING, 'agent', None, None, ), # 1
22124 
    (2, TType.I64, 'orderId', None, None, ), # 2
22125 
  )
22126 
 
22127 
  def __init__(self, agent=None, orderId=None,):
22128 
    self.agent = agent
22129 
    self.orderId = orderId
22130 
 
22131 
  def read(self, iprot):
22132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22134 
      return
22135 
    iprot.readStructBegin()
22136 
    while True:
22137 
      (fname, ftype, fid) = iprot.readFieldBegin()
22138 
      if ftype == TType.STOP:
22139 
        break
22140 
      if fid == 1:
22141 
        if ftype == TType.STRING:
22142 
          self.agent = iprot.readString();
22143 
        else:
22144 
          iprot.skip(ftype)
22145 
      elif fid == 2:
22146 
        if ftype == TType.I64:
22147 
          self.orderId = iprot.readI64();
22148 
        else:
22149 
          iprot.skip(ftype)
22150 
      else:
22151 
        iprot.skip(ftype)
22152 
      iprot.readFieldEnd()
22153 
    iprot.readStructEnd()
22154 
 
22155 
  def write(self, oprot):
22156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22158 
      return
22159 
    oprot.writeStructBegin('updateCODAgent_args')
22160 
    if self.agent is not None:
22161 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
22162 
      oprot.writeString(self.agent)
22163 
      oprot.writeFieldEnd()
22164 
    if self.orderId is not None:
22165 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
22166 
      oprot.writeI64(self.orderId)
22167 
      oprot.writeFieldEnd()
22168 
    oprot.writeFieldStop()
22169 
    oprot.writeStructEnd()
22170 
 
22171 
  def validate(self):
22172 
    return
22173 
 
22174 
 
22175 
  def __repr__(self):
22176 
    L = ['%s=%r' % (key, value)
22177 
      for key, value in self.__dict__.iteritems()]
22178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22179 
 
22180 
  def __eq__(self, other):
22181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22182 
 
22183 
  def __ne__(self, other):
22184 
    return not (self == other)
22185 
 
22186 
class updateCODAgent_result:
22187 
  """
22188 
  Attributes:
22189 
   - ex
22190 
  """
22191 
 
22192 
  thrift_spec = (
22193 
    None, # 0
22194 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22195 
  )
22196 
 
22197 
  def __init__(self, ex=None,):
22198 
    self.ex = ex
22199 
 
22200 
  def read(self, iprot):
22201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22203 
      return
22204 
    iprot.readStructBegin()
22205 
    while True:
22206 
      (fname, ftype, fid) = iprot.readFieldBegin()
22207 
      if ftype == TType.STOP:
22208 
        break
22209 
      if fid == 1:
22210 
        if ftype == TType.STRUCT:
22211 
          self.ex = TransactionServiceException()
22212 
          self.ex.read(iprot)
22213 
        else:
22214 
          iprot.skip(ftype)
22215 
      else:
22216 
        iprot.skip(ftype)
22217 
      iprot.readFieldEnd()
22218 
    iprot.readStructEnd()
22219 
 
22220 
  def write(self, oprot):
22221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22223 
      return
22224 
    oprot.writeStructBegin('updateCODAgent_result')
22225 
    if self.ex is not None:
22226 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22227 
      self.ex.write(oprot)
22228 
      oprot.writeFieldEnd()
22229 
    oprot.writeFieldStop()
22230 
    oprot.writeStructEnd()
22231 
 
22232 
  def validate(self):
22233 
    return
22234 
 
22235 
 
22236 
  def __repr__(self):
22237 
    L = ['%s=%r' % (key, value)
22238 
      for key, value in self.__dict__.iteritems()]
22239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22240 
 
22241 
  def __eq__(self, other):
22242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22243 
 
22244 
  def __ne__(self, other):
22245 
    return not (self == other)
22246 
 
5099 varun.gupt 22247 
class updateOrderAsPaidToVendor_args:
22248 
  """
22249 
  Attributes:
22250 
   - orderId
22251 
  """
22252 
 
22253 
  thrift_spec = (
22254 
    None, # 0
22255 
    (1, TType.I64, 'orderId', None, None, ), # 1
22256 
  )
22257 
 
22258 
  def __init__(self, orderId=None,):
22259 
    self.orderId = orderId
22260 
 
22261 
  def read(self, iprot):
22262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22264 
      return
22265 
    iprot.readStructBegin()
22266 
    while True:
22267 
      (fname, ftype, fid) = iprot.readFieldBegin()
22268 
      if ftype == TType.STOP:
22269 
        break
22270 
      if fid == 1:
22271 
        if ftype == TType.I64:
22272 
          self.orderId = iprot.readI64();
22273 
        else:
22274 
          iprot.skip(ftype)
22275 
      else:
22276 
        iprot.skip(ftype)
22277 
      iprot.readFieldEnd()
22278 
    iprot.readStructEnd()
22279 
 
22280 
  def write(self, oprot):
22281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22283 
      return
22284 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
22285 
    if self.orderId is not None:
22286 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22287 
      oprot.writeI64(self.orderId)
22288 
      oprot.writeFieldEnd()
22289 
    oprot.writeFieldStop()
22290 
    oprot.writeStructEnd()
22291 
 
22292 
  def validate(self):
22293 
    return
22294 
 
22295 
 
22296 
  def __repr__(self):
22297 
    L = ['%s=%r' % (key, value)
22298 
      for key, value in self.__dict__.iteritems()]
22299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22300 
 
22301 
  def __eq__(self, other):
22302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22303 
 
22304 
  def __ne__(self, other):
22305 
    return not (self == other)
22306 
 
22307 
class updateOrderAsPaidToVendor_result:
22308 
  """
22309 
  Attributes:
22310 
   - ex
22311 
  """
22312 
 
22313 
  thrift_spec = (
22314 
    None, # 0
22315 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22316 
  )
22317 
 
22318 
  def __init__(self, ex=None,):
22319 
    self.ex = ex
22320 
 
22321 
  def read(self, iprot):
22322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22324 
      return
22325 
    iprot.readStructBegin()
22326 
    while True:
22327 
      (fname, ftype, fid) = iprot.readFieldBegin()
22328 
      if ftype == TType.STOP:
22329 
        break
22330 
      if fid == 1:
22331 
        if ftype == TType.STRUCT:
22332 
          self.ex = TransactionServiceException()
22333 
          self.ex.read(iprot)
22334 
        else:
22335 
          iprot.skip(ftype)
22336 
      else:
22337 
        iprot.skip(ftype)
22338 
      iprot.readFieldEnd()
22339 
    iprot.readStructEnd()
22340 
 
22341 
  def write(self, oprot):
22342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22344 
      return
22345 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
22346 
    if self.ex is not None:
22347 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22348 
      self.ex.write(oprot)
22349 
      oprot.writeFieldEnd()
22350 
    oprot.writeFieldStop()
22351 
    oprot.writeStructEnd()
22352 
 
22353 
  def validate(self):
22354 
    return
22355 
 
22356 
 
22357 
  def __repr__(self):
22358 
    L = ['%s=%r' % (key, value)
22359 
      for key, value in self.__dict__.iteritems()]
22360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22361 
 
22362 
  def __eq__(self, other):
22363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22364 
 
22365 
  def __ne__(self, other):
22366 
    return not (self == other)
5208 varun.gupt 22367 
 
22368 
class getRefundedOrdersMarkedPaid_args:
22369 
 
22370 
  thrift_spec = (
22371 
  )
22372 
 
22373 
  def read(self, iprot):
22374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22376 
      return
22377 
    iprot.readStructBegin()
22378 
    while True:
22379 
      (fname, ftype, fid) = iprot.readFieldBegin()
22380 
      if ftype == TType.STOP:
22381 
        break
22382 
      else:
22383 
        iprot.skip(ftype)
22384 
      iprot.readFieldEnd()
22385 
    iprot.readStructEnd()
22386 
 
22387 
  def write(self, oprot):
22388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22390 
      return
22391 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
22392 
    oprot.writeFieldStop()
22393 
    oprot.writeStructEnd()
22394 
 
22395 
  def validate(self):
22396 
    return
22397 
 
22398 
 
22399 
  def __repr__(self):
22400 
    L = ['%s=%r' % (key, value)
22401 
      for key, value in self.__dict__.iteritems()]
22402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22403 
 
22404 
  def __eq__(self, other):
22405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22406 
 
22407 
  def __ne__(self, other):
22408 
    return not (self == other)
22409 
 
22410 
class getRefundedOrdersMarkedPaid_result:
22411 
  """
22412 
  Attributes:
22413 
   - success
22414 
   - ex
22415 
  """
22416 
 
22417 
  thrift_spec = (
22418 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22419 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22420 
  )
22421 
 
22422 
  def __init__(self, success=None, ex=None,):
22423 
    self.success = success
22424 
    self.ex = ex
22425 
 
22426 
  def read(self, iprot):
22427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22429 
      return
22430 
    iprot.readStructBegin()
22431 
    while True:
22432 
      (fname, ftype, fid) = iprot.readFieldBegin()
22433 
      if ftype == TType.STOP:
22434 
        break
22435 
      if fid == 0:
22436 
        if ftype == TType.LIST:
22437 
          self.success = []
5348 anupam.sin 22438 
          (_etype527, _size524) = iprot.readListBegin()
22439 
          for _i528 in xrange(_size524):
22440 
            _elem529 = Order()
22441 
            _elem529.read(iprot)
22442 
            self.success.append(_elem529)
5208 varun.gupt 22443 
          iprot.readListEnd()
22444 
        else:
22445 
          iprot.skip(ftype)
22446 
      elif fid == 1:
22447 
        if ftype == TType.STRUCT:
22448 
          self.ex = TransactionServiceException()
22449 
          self.ex.read(iprot)
22450 
        else:
22451 
          iprot.skip(ftype)
22452 
      else:
22453 
        iprot.skip(ftype)
22454 
      iprot.readFieldEnd()
22455 
    iprot.readStructEnd()
22456 
 
22457 
  def write(self, oprot):
22458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22460 
      return
22461 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
22462 
    if self.success is not None:
22463 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22464 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5348 anupam.sin 22465 
      for iter530 in self.success:
22466 
        iter530.write(oprot)
5208 varun.gupt 22467 
      oprot.writeListEnd()
22468 
      oprot.writeFieldEnd()
22469 
    if self.ex is not None:
22470 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22471 
      self.ex.write(oprot)
22472 
      oprot.writeFieldEnd()
22473 
    oprot.writeFieldStop()
22474 
    oprot.writeStructEnd()
22475 
 
22476 
  def validate(self):
22477 
    return
22478 
 
22479 
 
22480 
  def __repr__(self):
22481 
    L = ['%s=%r' % (key, value)
22482 
      for key, value in self.__dict__.iteritems()]
22483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22484 
 
22485 
  def __eq__(self, other):
22486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22487 
 
22488 
  def __ne__(self, other):
22489 
    return not (self == other)