Subversion Repositories SmartDukaan

Rev

Rev 5348 | Rev 5386 | 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 
 
5382 varun.gupt 1046 
  def getSettlementForReferenceId(self, referenceId, paymentGatewayId, isRefund):
4600 varun.gupt 1047 
    """
1048 
    Parameters:
5189 varun.gupt 1049 
     - referenceId
5382 varun.gupt 1050 
     - paymentGatewayId
5189 varun.gupt 1051 
     - isRefund
4600 varun.gupt 1052 
    """
1053 
    pass
1054 
 
1055 
  def getEBSSettlementSummaries(self, ):
1056 
    pass
1057 
 
1058 
  def markEBSSettlementUploaded(self, settlementId):
1059 
    """
1060 
    Parameters:
1061 
     - settlementId
1062 
    """
1063 
    pass
1064 
 
1065 
  def getEBSSettlementDate(self, settlementId):
1066 
    """
1067 
    Parameters:
1068 
     - settlementId
1069 
    """
1070 
    pass
1071 
 
4715 varun.gupt 1072 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1073 
    """
1074 
    Parameters:
1075 
     - settlementDateFrom
1076 
     - settlementDateTo
1077 
     - isRefund
1078 
    """
1079 
    pass
4600 varun.gupt 1080 
 
4715 varun.gupt 1081 
  def getReshippedOrderIds(self, orderIds):
1082 
    """
1083 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1084 
 
1085 
    Parameters:
1086 
     - orderIds
1087 
    """
1088 
    pass
1089 
 
5348 anupam.sin 1090 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
1091 
    """
1092 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
1093 
    the quantities for which the PO is raised.
1094 
 
1095 
    Parameters:
1096 
     - itemIdQuantityMap
1097 
     - purchaseOrderId
1098 
     - warehouseId
1099 
    """
1100 
    pass
1101 
 
4875 varun.gupt 1102 
  def getOrdersWhereVendorNotPaid(self, vendorId):
1103 
    """
1104 
    Parameters:
1105 
     - vendorId
1106 
    """
1107 
    pass
4757 mandeep.dh 1108 
 
5031 varun.gupt 1109 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1110 
    """
1111 
    Parameters:
1112 
     - startDate
1113 
     - endDate
1114 
    """
1115 
    pass
4875 varun.gupt 1116 
 
5067 varun.gupt 1117 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1118 
    """
1119 
    Parameters:
1120 
     - status
1121 
     - startDatetime
1122 
     - endDatetime
1123 
    """
1124 
    pass
5031 varun.gupt 1125 
 
5348 anupam.sin 1126 
  def updateCODAgent(self, agent, orderId):
1127 
    """
1128 
    Updates the agent who handled the COD verification call
1129 
 
1130 
    Parameters:
1131 
     - agent
1132 
     - orderId
1133 
    """
1134 
    pass
1135 
 
5099 varun.gupt 1136 
  def updateOrderAsPaidToVendor(self, orderId):
1137 
    """
1138 
    Parameters:
1139 
     - orderId
1140 
    """
1141 
    pass
5067 varun.gupt 1142 
 
5208 varun.gupt 1143 
  def getRefundedOrdersMarkedPaid(self, ):
1144 
    pass
5099 varun.gupt 1145 
 
5208 varun.gupt 1146 
 
3376 rajveer 1147 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1148 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1149 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1150 
 
1151 
  def createTransaction(self, transaction):
1152 
    """
1153 
    Parameters:
1154 
     - transaction
1155 
    """
1156 
    self.send_createTransaction(transaction)
132 ashish 1157 
    return self.recv_createTransaction()
94 ashish 1158 
 
1159 
  def send_createTransaction(self, transaction):
1160 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1161 
    args = createTransaction_args()
1162 
    args.transaction = transaction
1163 
    args.write(self._oprot)
1164 
    self._oprot.writeMessageEnd()
1165 
    self._oprot.trans.flush()
1166 
 
1167 
  def recv_createTransaction(self, ):
1168 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1169 
    if mtype == TMessageType.EXCEPTION:
1170 
      x = TApplicationException()
1171 
      x.read(self._iprot)
1172 
      self._iprot.readMessageEnd()
1173 
      raise x
1174 
    result = createTransaction_result()
1175 
    result.read(self._iprot)
1176 
    self._iprot.readMessageEnd()
3431 rajveer 1177 
    if result.success is not None:
132 ashish 1178 
      return result.success
3431 rajveer 1179 
    if result.ex is not None:
94 ashish 1180 
      raise result.ex
132 ashish 1181 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1182 
 
1183 
  def getTransaction(self, id):
1184 
    """
1185 
    Parameters:
1186 
     - id
1187 
    """
1188 
    self.send_getTransaction(id)
1189 
    return self.recv_getTransaction()
1190 
 
1191 
  def send_getTransaction(self, id):
1192 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1193 
    args = getTransaction_args()
1194 
    args.id = id
1195 
    args.write(self._oprot)
1196 
    self._oprot.writeMessageEnd()
1197 
    self._oprot.trans.flush()
1198 
 
1199 
  def recv_getTransaction(self, ):
1200 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1201 
    if mtype == TMessageType.EXCEPTION:
1202 
      x = TApplicationException()
1203 
      x.read(self._iprot)
1204 
      self._iprot.readMessageEnd()
1205 
      raise x
1206 
    result = getTransaction_result()
1207 
    result.read(self._iprot)
1208 
    self._iprot.readMessageEnd()
3431 rajveer 1209 
    if result.success is not None:
94 ashish 1210 
      return result.success
3431 rajveer 1211 
    if result.ex is not None:
94 ashish 1212 
      raise result.ex
1213 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1214 
 
1215 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1216 
    """
1217 
    Parameters:
1218 
     - customerId
1219 
     - from_date
1220 
     - to_date
1221 
     - status
1222 
    """
1223 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1224 
    return self.recv_getTransactionsForCustomer()
1225 
 
1226 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1227 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1228 
    args = getTransactionsForCustomer_args()
1229 
    args.customerId = customerId
1230 
    args.from_date = from_date
1231 
    args.to_date = to_date
1232 
    args.status = status
1233 
    args.write(self._oprot)
1234 
    self._oprot.writeMessageEnd()
1235 
    self._oprot.trans.flush()
1236 
 
1237 
  def recv_getTransactionsForCustomer(self, ):
1238 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1239 
    if mtype == TMessageType.EXCEPTION:
1240 
      x = TApplicationException()
1241 
      x.read(self._iprot)
1242 
      self._iprot.readMessageEnd()
1243 
      raise x
1244 
    result = getTransactionsForCustomer_result()
1245 
    result.read(self._iprot)
1246 
    self._iprot.readMessageEnd()
3431 rajveer 1247 
    if result.success is not None:
94 ashish 1248 
      return result.success
3431 rajveer 1249 
    if result.ex is not None:
94 ashish 1250 
      raise result.ex
1251 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1252 
 
132 ashish 1253 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1254 
    """
1255 
    Parameters:
1256 
     - shoppingCartId
1257 
    """
1258 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1259 
    return self.recv_getTransactionsForShoppingCartId()
1260 
 
1261 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1262 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1263 
    args = getTransactionsForShoppingCartId_args()
1264 
    args.shoppingCartId = shoppingCartId
1265 
    args.write(self._oprot)
1266 
    self._oprot.writeMessageEnd()
1267 
    self._oprot.trans.flush()
1268 
 
1269 
  def recv_getTransactionsForShoppingCartId(self, ):
1270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1271 
    if mtype == TMessageType.EXCEPTION:
1272 
      x = TApplicationException()
1273 
      x.read(self._iprot)
1274 
      self._iprot.readMessageEnd()
1275 
      raise x
1276 
    result = getTransactionsForShoppingCartId_result()
1277 
    result.read(self._iprot)
1278 
    self._iprot.readMessageEnd()
3431 rajveer 1279 
    if result.success is not None:
132 ashish 1280 
      return result.success
3431 rajveer 1281 
    if result.ex is not None:
132 ashish 1282 
      raise result.ex
1283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1284 
 
94 ashish 1285 
  def getTransactionStatus(self, transactionId):
1286 
    """
1287 
    Parameters:
1288 
     - transactionId
1289 
    """
1290 
    self.send_getTransactionStatus(transactionId)
1291 
    return self.recv_getTransactionStatus()
1292 
 
1293 
  def send_getTransactionStatus(self, transactionId):
1294 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1295 
    args = getTransactionStatus_args()
1296 
    args.transactionId = transactionId
1297 
    args.write(self._oprot)
1298 
    self._oprot.writeMessageEnd()
1299 
    self._oprot.trans.flush()
1300 
 
1301 
  def recv_getTransactionStatus(self, ):
1302 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1303 
    if mtype == TMessageType.EXCEPTION:
1304 
      x = TApplicationException()
1305 
      x.read(self._iprot)
1306 
      self._iprot.readMessageEnd()
1307 
      raise x
1308 
    result = getTransactionStatus_result()
1309 
    result.read(self._iprot)
1310 
    self._iprot.readMessageEnd()
3431 rajveer 1311 
    if result.success is not None:
94 ashish 1312 
      return result.success
3431 rajveer 1313 
    if result.ex is not None:
94 ashish 1314 
      raise result.ex
1315 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1316 
 
1317 
  def changeTransactionStatus(self, transactionId, status, description):
1318 
    """
1319 
    Parameters:
1320 
     - transactionId
1321 
     - status
1322 
     - description
1323 
    """
1324 
    self.send_changeTransactionStatus(transactionId, status, description)
1325 
    return self.recv_changeTransactionStatus()
1326 
 
1327 
  def send_changeTransactionStatus(self, transactionId, status, description):
1328 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1329 
    args = changeTransactionStatus_args()
1330 
    args.transactionId = transactionId
1331 
    args.status = status
1332 
    args.description = description
1333 
    args.write(self._oprot)
1334 
    self._oprot.writeMessageEnd()
1335 
    self._oprot.trans.flush()
1336 
 
1337 
  def recv_changeTransactionStatus(self, ):
1338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1339 
    if mtype == TMessageType.EXCEPTION:
1340 
      x = TApplicationException()
1341 
      x.read(self._iprot)
1342 
      self._iprot.readMessageEnd()
1343 
      raise x
1344 
    result = changeTransactionStatus_result()
1345 
    result.read(self._iprot)
1346 
    self._iprot.readMessageEnd()
3431 rajveer 1347 
    if result.success is not None:
94 ashish 1348 
      return result.success
3431 rajveer 1349 
    if result.ex is not None:
94 ashish 1350 
      raise result.ex
1351 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1352 
 
1398 varun.gupt 1353 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1354 
    """
1355 
    Parameters:
1356 
     - transactionId
1357 
    """
1398 varun.gupt 1358 
    self.send_enqueueTransactionInfoEmail(transactionId)
1359 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1360 
 
1398 varun.gupt 1361 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1362 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1363 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1364 
    args.transactionId = transactionId
1365 
    args.write(self._oprot)
1366 
    self._oprot.writeMessageEnd()
1367 
    self._oprot.trans.flush()
1368 
 
1398 varun.gupt 1369 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1370 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1371 
    if mtype == TMessageType.EXCEPTION:
1372 
      x = TApplicationException()
1373 
      x.read(self._iprot)
1374 
      self._iprot.readMessageEnd()
1375 
      raise x
1398 varun.gupt 1376 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1377 
    result.read(self._iprot)
1378 
    self._iprot.readMessageEnd()
3431 rajveer 1379 
    if result.success is not None:
1382 varun.gupt 1380 
      return result.success
3431 rajveer 1381 
    if result.ex is not None:
1382 varun.gupt 1382 
      raise result.ex
1398 varun.gupt 1383 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1384 
 
4801 anupam.sin 1385 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1386 
    """
1387 
    Parameters:
4801 anupam.sin 1388 
     - statuses
483 rajveer 1389 
     - from_date
1390 
     - to_date
1391 
     - warehouse_id
94 ashish 1392 
    """
4801 anupam.sin 1393 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1394 
    return self.recv_getAllOrders()
94 ashish 1395 
 
4801 anupam.sin 1396 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1397 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1398 
    args = getAllOrders_args()
4801 anupam.sin 1399 
    args.statuses = statuses
483 rajveer 1400 
    args.from_date = from_date
1401 
    args.to_date = to_date
1402 
    args.warehouse_id = warehouse_id
94 ashish 1403 
    args.write(self._oprot)
1404 
    self._oprot.writeMessageEnd()
1405 
    self._oprot.trans.flush()
1406 
 
483 rajveer 1407 
  def recv_getAllOrders(self, ):
94 ashish 1408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1409 
    if mtype == TMessageType.EXCEPTION:
1410 
      x = TApplicationException()
1411 
      x.read(self._iprot)
1412 
      self._iprot.readMessageEnd()
1413 
      raise x
483 rajveer 1414 
    result = getAllOrders_result()
94 ashish 1415 
    result.read(self._iprot)
1416 
    self._iprot.readMessageEnd()
3431 rajveer 1417 
    if result.success is not None:
94 ashish 1418 
      return result.success
3431 rajveer 1419 
    if result.ex is not None:
94 ashish 1420 
      raise result.ex
483 rajveer 1421 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1422 
 
4133 chandransh 1423 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1424 
    """
1425 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1426 
    Pass the status as null and the limit as 0 to ignore them.
1427 
 
1428 
    Parameters:
1429 
     - statuses
1430 
     - offset
1431 
     - limit
1432 
     - warehouse_id
1433 
    """
1434 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1435 
    return self.recv_getOrdersInBatch()
1436 
 
1437 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1438 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1439 
    args = getOrdersInBatch_args()
1440 
    args.statuses = statuses
1441 
    args.offset = offset
1442 
    args.limit = limit
1443 
    args.warehouse_id = warehouse_id
1444 
    args.write(self._oprot)
1445 
    self._oprot.writeMessageEnd()
1446 
    self._oprot.trans.flush()
1447 
 
1448 
  def recv_getOrdersInBatch(self, ):
1449 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1450 
    if mtype == TMessageType.EXCEPTION:
1451 
      x = TApplicationException()
1452 
      x.read(self._iprot)
1453 
      self._iprot.readMessageEnd()
1454 
      raise x
1455 
    result = getOrdersInBatch_result()
1456 
    result.read(self._iprot)
1457 
    self._iprot.readMessageEnd()
1458 
    if result.success is not None:
1459 
      return result.success
1460 
    if result.ex is not None:
1461 
      raise result.ex
1462 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1463 
 
1464 
  def getOrderCount(self, statuses, warehouseId):
1465 
    """
1466 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1467 
 
1468 
    Parameters:
1469 
     - statuses
1470 
     - warehouseId
1471 
    """
1472 
    self.send_getOrderCount(statuses, warehouseId)
1473 
    return self.recv_getOrderCount()
1474 
 
1475 
  def send_getOrderCount(self, statuses, warehouseId):
1476 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1477 
    args = getOrderCount_args()
1478 
    args.statuses = statuses
1479 
    args.warehouseId = warehouseId
1480 
    args.write(self._oprot)
1481 
    self._oprot.writeMessageEnd()
1482 
    self._oprot.trans.flush()
1483 
 
1484 
  def recv_getOrderCount(self, ):
1485 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1486 
    if mtype == TMessageType.EXCEPTION:
1487 
      x = TApplicationException()
1488 
      x.read(self._iprot)
1489 
      self._iprot.readMessageEnd()
1490 
      raise x
1491 
    result = getOrderCount_result()
1492 
    result.read(self._iprot)
1493 
    self._iprot.readMessageEnd()
1494 
    if result.success is not None:
1495 
      return result.success
1496 
    if result.ex is not None:
1497 
      raise result.ex
1498 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1499 
 
999 varun.gupt 1500 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1501 
    """
1132 chandransh 1502 
    Returns orders within a range of their billing dates
3431 rajveer 1503 
 
999 varun.gupt 1504 
    Parameters:
1505 
     - status
1506 
     - start_billing_date
1507 
     - end_billing_date
1508 
     - warehouse_id
1509 
    """
1510 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1511 
    return self.recv_getOrdersByBillingDate()
1512 
 
1513 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1514 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1515 
    args = getOrdersByBillingDate_args()
1516 
    args.status = status
1517 
    args.start_billing_date = start_billing_date
1518 
    args.end_billing_date = end_billing_date
1519 
    args.warehouse_id = warehouse_id
1520 
    args.write(self._oprot)
1521 
    self._oprot.writeMessageEnd()
1522 
    self._oprot.trans.flush()
1523 
 
1524 
  def recv_getOrdersByBillingDate(self, ):
1525 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1526 
    if mtype == TMessageType.EXCEPTION:
1527 
      x = TApplicationException()
1528 
      x.read(self._iprot)
1529 
      self._iprot.readMessageEnd()
1530 
      raise x
1531 
    result = getOrdersByBillingDate_result()
1532 
    result.read(self._iprot)
1533 
    self._iprot.readMessageEnd()
3431 rajveer 1534 
    if result.success is not None:
999 varun.gupt 1535 
      return result.success
3431 rajveer 1536 
    if result.ex is not None:
999 varun.gupt 1537 
      raise result.ex
1538 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1539 
 
3451 chandransh 1540 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1541 
    """
1542 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1543 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1544 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1545 
 
3427 chandransh 1546 
    Parameters:
1547 
     - fromShippingDate
1548 
     - toShippingDate
1549 
     - providerId
1550 
     - warehouseId
3451 chandransh 1551 
     - cod
3427 chandransh 1552 
    """
3451 chandransh 1553 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1554 
    return self.recv_getOrdersByShippingDate()
1555 
 
3451 chandransh 1556 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1557 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1558 
    args = getOrdersByShippingDate_args()
1559 
    args.fromShippingDate = fromShippingDate
1560 
    args.toShippingDate = toShippingDate
1561 
    args.providerId = providerId
1562 
    args.warehouseId = warehouseId
3451 chandransh 1563 
    args.cod = cod
3427 chandransh 1564 
    args.write(self._oprot)
1565 
    self._oprot.writeMessageEnd()
1566 
    self._oprot.trans.flush()
1567 
 
1568 
  def recv_getOrdersByShippingDate(self, ):
1569 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1570 
    if mtype == TMessageType.EXCEPTION:
1571 
      x = TApplicationException()
1572 
      x.read(self._iprot)
1573 
      self._iprot.readMessageEnd()
1574 
      raise x
1575 
    result = getOrdersByShippingDate_result()
1576 
    result.read(self._iprot)
1577 
    self._iprot.readMessageEnd()
3431 rajveer 1578 
    if result.success is not None:
3427 chandransh 1579 
      return result.success
3431 rajveer 1580 
    if result.ex is not None:
3427 chandransh 1581 
      raise result.ex
1582 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1583 
 
1382 varun.gupt 1584 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1585 
    """
1586 
    Returns order ids for orders which can be returned
3431 rajveer 1587 
 
1382 varun.gupt 1588 
    Parameters:
1589 
     - customer_id
1590 
     - limit
1591 
    """
1592 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1593 
    return self.recv_getReturnableOrdersForCustomer()
1594 
 
1595 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1596 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1597 
    args = getReturnableOrdersForCustomer_args()
1598 
    args.customer_id = customer_id
1599 
    args.limit = limit
1600 
    args.write(self._oprot)
1601 
    self._oprot.writeMessageEnd()
1602 
    self._oprot.trans.flush()
1603 
 
1604 
  def recv_getReturnableOrdersForCustomer(self, ):
1605 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1606 
    if mtype == TMessageType.EXCEPTION:
1607 
      x = TApplicationException()
1608 
      x.read(self._iprot)
1609 
      self._iprot.readMessageEnd()
1610 
      raise x
1611 
    result = getReturnableOrdersForCustomer_result()
1612 
    result.read(self._iprot)
1613 
    self._iprot.readMessageEnd()
3431 rajveer 1614 
    if result.success is not None:
1382 varun.gupt 1615 
      return result.success
3431 rajveer 1616 
    if result.ex is not None:
1382 varun.gupt 1617 
      raise result.ex
1618 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1619 
 
1620 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1621 
    """
1622 
    Returns order ids for orders which can be cancelled
3431 rajveer 1623 
 
1382 varun.gupt 1624 
    Parameters:
1625 
     - customer_id
1626 
     - limit
1627 
    """
1628 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1629 
    return self.recv_getCancellableOrdersForCustomer()
1630 
 
1631 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1632 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1633 
    args = getCancellableOrdersForCustomer_args()
1634 
    args.customer_id = customer_id
1635 
    args.limit = limit
1636 
    args.write(self._oprot)
1637 
    self._oprot.writeMessageEnd()
1638 
    self._oprot.trans.flush()
1639 
 
1640 
  def recv_getCancellableOrdersForCustomer(self, ):
1641 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1642 
    if mtype == TMessageType.EXCEPTION:
1643 
      x = TApplicationException()
1644 
      x.read(self._iprot)
1645 
      self._iprot.readMessageEnd()
1646 
      raise x
1647 
    result = getCancellableOrdersForCustomer_result()
1648 
    result.read(self._iprot)
1649 
    self._iprot.readMessageEnd()
3431 rajveer 1650 
    if result.success is not None:
1382 varun.gupt 1651 
      return result.success
3431 rajveer 1652 
    if result.ex is not None:
1382 varun.gupt 1653 
      raise result.ex
1654 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1655 
 
483 rajveer 1656 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1657 
    """
1658 
    Parameters:
483 rajveer 1659 
     - orderId
1660 
     - status
1661 
     - description
94 ashish 1662 
    """
483 rajveer 1663 
    self.send_changeOrderStatus(orderId, status, description)
1664 
    return self.recv_changeOrderStatus()
94 ashish 1665 
 
483 rajveer 1666 
  def send_changeOrderStatus(self, orderId, status, description):
1667 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1668 
    args = changeOrderStatus_args()
1669 
    args.orderId = orderId
1670 
    args.status = status
1671 
    args.description = description
94 ashish 1672 
    args.write(self._oprot)
1673 
    self._oprot.writeMessageEnd()
1674 
    self._oprot.trans.flush()
1675 
 
483 rajveer 1676 
  def recv_changeOrderStatus(self, ):
94 ashish 1677 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1678 
    if mtype == TMessageType.EXCEPTION:
1679 
      x = TApplicationException()
1680 
      x.read(self._iprot)
1681 
      self._iprot.readMessageEnd()
1682 
      raise x
483 rajveer 1683 
    result = changeOrderStatus_result()
94 ashish 1684 
    result.read(self._iprot)
1685 
    self._iprot.readMessageEnd()
3431 rajveer 1686 
    if result.success is not None:
94 ashish 1687 
      return result.success
3431 rajveer 1688 
    if result.ex is not None:
94 ashish 1689 
      raise result.ex
483 rajveer 1690 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1691 
 
1528 ankur.sing 1692 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1693 
    """
1528 ankur.sing 1694 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1695 
    only user who owns the transaction can view its order details.
3431 rajveer 1696 
 
94 ashish 1697 
    Parameters:
1698 
     - transactionId
1528 ankur.sing 1699 
     - customerId
94 ashish 1700 
    """
1528 ankur.sing 1701 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1702 
    return self.recv_getOrdersForTransaction()
94 ashish 1703 
 
1528 ankur.sing 1704 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1705 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1706 
    args = getOrdersForTransaction_args()
94 ashish 1707 
    args.transactionId = transactionId
1528 ankur.sing 1708 
    args.customerId = customerId
94 ashish 1709 
    args.write(self._oprot)
1710 
    self._oprot.writeMessageEnd()
1711 
    self._oprot.trans.flush()
1712 
 
483 rajveer 1713 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1715 
    if mtype == TMessageType.EXCEPTION:
1716 
      x = TApplicationException()
1717 
      x.read(self._iprot)
1718 
      self._iprot.readMessageEnd()
1719 
      raise x
483 rajveer 1720 
    result = getOrdersForTransaction_result()
94 ashish 1721 
    result.read(self._iprot)
1722 
    self._iprot.readMessageEnd()
3431 rajveer 1723 
    if result.success is not None:
94 ashish 1724 
      return result.success
3431 rajveer 1725 
    if result.ex is not None:
94 ashish 1726 
      raise result.ex
483 rajveer 1727 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1728 
 
3014 chandransh 1729 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1730 
    """
3014 chandransh 1731 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1732 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1733 
 
94 ashish 1734 
    Parameters:
483 rajveer 1735 
     - customerId
1736 
     - from_date
1737 
     - to_date
3014 chandransh 1738 
     - statuses
94 ashish 1739 
    """
3014 chandransh 1740 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1741 
    return self.recv_getOrdersForCustomer()
94 ashish 1742 
 
3014 chandransh 1743 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1744 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1745 
    args = getOrdersForCustomer_args()
1746 
    args.customerId = customerId
1747 
    args.from_date = from_date
1748 
    args.to_date = to_date
3014 chandransh 1749 
    args.statuses = statuses
94 ashish 1750 
    args.write(self._oprot)
1751 
    self._oprot.writeMessageEnd()
1752 
    self._oprot.trans.flush()
1753 
 
483 rajveer 1754 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1756 
    if mtype == TMessageType.EXCEPTION:
1757 
      x = TApplicationException()
1758 
      x.read(self._iprot)
1759 
      self._iprot.readMessageEnd()
1760 
      raise x
483 rajveer 1761 
    result = getOrdersForCustomer_result()
94 ashish 1762 
    result.read(self._iprot)
1763 
    self._iprot.readMessageEnd()
3431 rajveer 1764 
    if result.success is not None:
94 ashish 1765 
      return result.success
3431 rajveer 1766 
    if result.ex is not None:
94 ashish 1767 
      raise result.ex
483 rajveer 1768 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1769 
 
483 rajveer 1770 
  def createOrder(self, order):
94 ashish 1771 
    """
1772 
    Parameters:
483 rajveer 1773 
     - order
94 ashish 1774 
    """
483 rajveer 1775 
    self.send_createOrder(order)
1776 
    return self.recv_createOrder()
94 ashish 1777 
 
483 rajveer 1778 
  def send_createOrder(self, order):
1779 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1780 
    args = createOrder_args()
1781 
    args.order = order
94 ashish 1782 
    args.write(self._oprot)
1783 
    self._oprot.writeMessageEnd()
1784 
    self._oprot.trans.flush()
1785 
 
483 rajveer 1786 
  def recv_createOrder(self, ):
94 ashish 1787 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1788 
    if mtype == TMessageType.EXCEPTION:
1789 
      x = TApplicationException()
1790 
      x.read(self._iprot)
1791 
      self._iprot.readMessageEnd()
1792 
      raise x
483 rajveer 1793 
    result = createOrder_result()
94 ashish 1794 
    result.read(self._iprot)
1795 
    self._iprot.readMessageEnd()
3431 rajveer 1796 
    if result.success is not None:
94 ashish 1797 
      return result.success
3431 rajveer 1798 
    if result.ex is not None:
94 ashish 1799 
      raise result.ex
483 rajveer 1800 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1801 
 
483 rajveer 1802 
  def getOrder(self, id):
94 ashish 1803 
    """
1804 
    Parameters:
483 rajveer 1805 
     - id
94 ashish 1806 
    """
483 rajveer 1807 
    self.send_getOrder(id)
1808 
    return self.recv_getOrder()
94 ashish 1809 
 
483 rajveer 1810 
  def send_getOrder(self, id):
1811 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1812 
    args = getOrder_args()
1813 
    args.id = id
94 ashish 1814 
    args.write(self._oprot)
1815 
    self._oprot.writeMessageEnd()
1816 
    self._oprot.trans.flush()
1817 
 
483 rajveer 1818 
  def recv_getOrder(self, ):
94 ashish 1819 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1820 
    if mtype == TMessageType.EXCEPTION:
1821 
      x = TApplicationException()
1822 
      x.read(self._iprot)
1823 
      self._iprot.readMessageEnd()
1824 
      raise x
483 rajveer 1825 
    result = getOrder_result()
94 ashish 1826 
    result.read(self._iprot)
1827 
    self._iprot.readMessageEnd()
3431 rajveer 1828 
    if result.success is not None:
94 ashish 1829 
      return result.success
3431 rajveer 1830 
    if result.ex is not None:
94 ashish 1831 
      raise result.ex
483 rajveer 1832 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1833 
 
483 rajveer 1834 
  def getLineItemsForOrder(self, orderId):
94 ashish 1835 
    """
1836 
    Parameters:
483 rajveer 1837 
     - orderId
94 ashish 1838 
    """
483 rajveer 1839 
    self.send_getLineItemsForOrder(orderId)
1840 
    return self.recv_getLineItemsForOrder()
94 ashish 1841 
 
483 rajveer 1842 
  def send_getLineItemsForOrder(self, orderId):
1843 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1844 
    args = getLineItemsForOrder_args()
1845 
    args.orderId = orderId
94 ashish 1846 
    args.write(self._oprot)
1847 
    self._oprot.writeMessageEnd()
1848 
    self._oprot.trans.flush()
1849 
 
483 rajveer 1850 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1851 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1852 
    if mtype == TMessageType.EXCEPTION:
1853 
      x = TApplicationException()
1854 
      x.read(self._iprot)
1855 
      self._iprot.readMessageEnd()
1856 
      raise x
483 rajveer 1857 
    result = getLineItemsForOrder_result()
94 ashish 1858 
    result.read(self._iprot)
1859 
    self._iprot.readMessageEnd()
3431 rajveer 1860 
    if result.success is not None:
94 ashish 1861 
      return result.success
3431 rajveer 1862 
    if result.ex is not None:
94 ashish 1863 
      raise result.ex
483 rajveer 1864 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1865 
 
4999 phani.kuma 1866 
  def getOrderList(self, order_ids):
1867 
    """
1868 
    Parameters:
1869 
     - order_ids
1870 
    """
1871 
    self.send_getOrderList(order_ids)
1872 
    return self.recv_getOrderList()
1873 
 
1874 
  def send_getOrderList(self, order_ids):
1875 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
1876 
    args = getOrderList_args()
1877 
    args.order_ids = order_ids
1878 
    args.write(self._oprot)
1879 
    self._oprot.writeMessageEnd()
1880 
    self._oprot.trans.flush()
1881 
 
1882 
  def recv_getOrderList(self, ):
1883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1884 
    if mtype == TMessageType.EXCEPTION:
1885 
      x = TApplicationException()
1886 
      x.read(self._iprot)
1887 
      self._iprot.readMessageEnd()
1888 
      raise x
1889 
    result = getOrderList_result()
1890 
    result.read(self._iprot)
1891 
    self._iprot.readMessageEnd()
1892 
    if result.success is not None:
1893 
      return result.success
1894 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
1895 
 
1528 ankur.sing 1896 
  def getOrderForCustomer(self, orderId, customerId):
1897 
    """
1898 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1899 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1900 
 
1528 ankur.sing 1901 
    Parameters:
1902 
     - orderId
1903 
     - customerId
1904 
    """
1905 
    self.send_getOrderForCustomer(orderId, customerId)
1906 
    return self.recv_getOrderForCustomer()
1907 
 
1908 
  def send_getOrderForCustomer(self, orderId, customerId):
1909 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1910 
    args = getOrderForCustomer_args()
1911 
    args.orderId = orderId
1912 
    args.customerId = customerId
1913 
    args.write(self._oprot)
1914 
    self._oprot.writeMessageEnd()
1915 
    self._oprot.trans.flush()
1916 
 
1917 
  def recv_getOrderForCustomer(self, ):
1918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1919 
    if mtype == TMessageType.EXCEPTION:
1920 
      x = TApplicationException()
1921 
      x.read(self._iprot)
1922 
      self._iprot.readMessageEnd()
1923 
      raise x
1924 
    result = getOrderForCustomer_result()
1925 
    result.read(self._iprot)
1926 
    self._iprot.readMessageEnd()
3431 rajveer 1927 
    if result.success is not None:
1528 ankur.sing 1928 
      return result.success
3431 rajveer 1929 
    if result.ex is not None:
1528 ankur.sing 1930 
      raise result.ex
1931 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1932 
 
4444 rajveer 1933 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1934 
    """
1935 
    Parameters:
4394 rajveer 1936 
     - type
4444 rajveer 1937 
     - warehouseId
4394 rajveer 1938 
     - status
1939 
     - timestamp
3064 chandransh 1940 
    """
4444 rajveer 1941 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1942 
    return self.recv_getAlerts()
1943 
 
4444 rajveer 1944 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1945 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1946 
    args = getAlerts_args()
4394 rajveer 1947 
    args.type = type
4444 rajveer 1948 
    args.warehouseId = warehouseId
4394 rajveer 1949 
    args.status = status
1950 
    args.timestamp = timestamp
3064 chandransh 1951 
    args.write(self._oprot)
1952 
    self._oprot.writeMessageEnd()
1953 
    self._oprot.trans.flush()
1954 
 
1955 
  def recv_getAlerts(self, ):
1956 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1957 
    if mtype == TMessageType.EXCEPTION:
1958 
      x = TApplicationException()
1959 
      x.read(self._iprot)
1960 
      self._iprot.readMessageEnd()
1961 
      raise x
1962 
    result = getAlerts_result()
1963 
    result.read(self._iprot)
1964 
    self._iprot.readMessageEnd()
3431 rajveer 1965 
    if result.success is not None:
3064 chandransh 1966 
      return result.success
1967 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1968 
 
4444 rajveer 1969 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1970 
    """
1971 
    Parameters:
1972 
     - type
4444 rajveer 1973 
     - warehouseId
4394 rajveer 1974 
     - description
3064 chandransh 1975 
    """
4444 rajveer 1976 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1977 
    self.recv_addAlert()
3064 chandransh 1978 
 
4444 rajveer 1979 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1980 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1981 
    args = addAlert_args()
3064 chandransh 1982 
    args.type = type
4444 rajveer 1983 
    args.warehouseId = warehouseId
4394 rajveer 1984 
    args.description = description
3064 chandransh 1985 
    args.write(self._oprot)
1986 
    self._oprot.writeMessageEnd()
1987 
    self._oprot.trans.flush()
1988 
 
4394 rajveer 1989 
  def recv_addAlert(self, ):
3064 chandransh 1990 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1991 
    if mtype == TMessageType.EXCEPTION:
1992 
      x = TApplicationException()
1993 
      x.read(self._iprot)
1994 
      self._iprot.readMessageEnd()
1995 
      raise x
4394 rajveer 1996 
    result = addAlert_result()
3064 chandransh 1997 
    result.read(self._iprot)
1998 
    self._iprot.readMessageEnd()
1999 
    return
2000 
 
4444 rajveer 2001 
  def markAlertsAsSeen(self, warehouseId):
2002 
    """
2003 
    Parameters:
2004 
     - warehouseId
2005 
    """
2006 
    self.send_markAlertsAsSeen(warehouseId)
2007 
    self.recv_markAlertsAsSeen()
2008 
 
2009 
  def send_markAlertsAsSeen(self, warehouseId):
2010 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2011 
    args = markAlertsAsSeen_args()
2012 
    args.warehouseId = warehouseId
2013 
    args.write(self._oprot)
2014 
    self._oprot.writeMessageEnd()
2015 
    self._oprot.trans.flush()
2016 
 
2017 
  def recv_markAlertsAsSeen(self, ):
2018 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2019 
    if mtype == TMessageType.EXCEPTION:
2020 
      x = TApplicationException()
2021 
      x.read(self._iprot)
2022 
      self._iprot.readMessageEnd()
2023 
      raise x
2024 
    result = markAlertsAsSeen_result()
2025 
    result.read(self._iprot)
2026 
    self._iprot.readMessageEnd()
2027 
    return
2028 
 
3064 chandransh 2029 
  def getValidOrderCount(self, ):
2030 
    """
2031 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2032 
    """
2033 
    self.send_getValidOrderCount()
2034 
    return self.recv_getValidOrderCount()
2035 
 
2036 
  def send_getValidOrderCount(self, ):
2037 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2038 
    args = getValidOrderCount_args()
2039 
    args.write(self._oprot)
2040 
    self._oprot.writeMessageEnd()
2041 
    self._oprot.trans.flush()
2042 
 
2043 
  def recv_getValidOrderCount(self, ):
2044 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2045 
    if mtype == TMessageType.EXCEPTION:
2046 
      x = TApplicationException()
2047 
      x.read(self._iprot)
2048 
      self._iprot.readMessageEnd()
2049 
      raise x
2050 
    result = getValidOrderCount_result()
2051 
    result.read(self._iprot)
2052 
    self._iprot.readMessageEnd()
3431 rajveer 2053 
    if result.success is not None:
3064 chandransh 2054 
      return result.success
2055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2056 
 
2057 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2058 
    """
2059 
    Returns the number of distinct customers who have done successful transactions
2060 
    """
2061 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2062 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2063 
 
2064 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2065 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2066 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2067 
    args.write(self._oprot)
2068 
    self._oprot.writeMessageEnd()
2069 
    self._oprot.trans.flush()
2070 
 
2071 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2073 
    if mtype == TMessageType.EXCEPTION:
2074 
      x = TApplicationException()
2075 
      x.read(self._iprot)
2076 
      self._iprot.readMessageEnd()
2077 
      raise x
2078 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2079 
    result.read(self._iprot)
2080 
    self._iprot.readMessageEnd()
3431 rajveer 2081 
    if result.success is not None:
3064 chandransh 2082 
      return result.success
2083 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2084 
 
2085 
  def getValidOrdersAmountRange(self, ):
2086 
    """
2087 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2088 
    List contains two values, first minimum amount and second maximum amount.
2089 
    """
2090 
    self.send_getValidOrdersAmountRange()
2091 
    return self.recv_getValidOrdersAmountRange()
2092 
 
2093 
  def send_getValidOrdersAmountRange(self, ):
2094 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2095 
    args = getValidOrdersAmountRange_args()
2096 
    args.write(self._oprot)
2097 
    self._oprot.writeMessageEnd()
2098 
    self._oprot.trans.flush()
2099 
 
2100 
  def recv_getValidOrdersAmountRange(self, ):
2101 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2102 
    if mtype == TMessageType.EXCEPTION:
2103 
      x = TApplicationException()
2104 
      x.read(self._iprot)
2105 
      self._iprot.readMessageEnd()
2106 
      raise x
2107 
    result = getValidOrdersAmountRange_result()
2108 
    result.read(self._iprot)
2109 
    self._iprot.readMessageEnd()
3431 rajveer 2110 
    if result.success is not None:
3064 chandransh 2111 
      return result.success
2112 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2113 
 
2114 
  def getValidOrders(self, limit):
2115 
    """
2116 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2117 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2118 
 
3064 chandransh 2119 
    Parameters:
2120 
     - limit
2121 
    """
2122 
    self.send_getValidOrders(limit)
2123 
    return self.recv_getValidOrders()
2124 
 
2125 
  def send_getValidOrders(self, limit):
2126 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2127 
    args = getValidOrders_args()
2128 
    args.limit = limit
2129 
    args.write(self._oprot)
2130 
    self._oprot.writeMessageEnd()
2131 
    self._oprot.trans.flush()
2132 
 
2133 
  def recv_getValidOrders(self, ):
2134 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2135 
    if mtype == TMessageType.EXCEPTION:
2136 
      x = TApplicationException()
2137 
      x.read(self._iprot)
2138 
      self._iprot.readMessageEnd()
2139 
      raise x
2140 
    result = getValidOrders_result()
2141 
    result.read(self._iprot)
2142 
    self._iprot.readMessageEnd()
3431 rajveer 2143 
    if result.success is not None:
3064 chandransh 2144 
      return result.success
2145 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2146 
 
1220 chandransh 2147 
  def batchOrders(self, warehouseId):
2148 
    """
2149 
    Create a batch of all the pending orders for the given warehouse.
2150 
    The returned list is orderd by created_timestamp.
2151 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2152 
 
1220 chandransh 2153 
    Parameters:
2154 
     - warehouseId
2155 
    """
2156 
    self.send_batchOrders(warehouseId)
2157 
    return self.recv_batchOrders()
2158 
 
2159 
  def send_batchOrders(self, warehouseId):
2160 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2161 
    args = batchOrders_args()
2162 
    args.warehouseId = warehouseId
2163 
    args.write(self._oprot)
2164 
    self._oprot.writeMessageEnd()
2165 
    self._oprot.trans.flush()
2166 
 
2167 
  def recv_batchOrders(self, ):
2168 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2169 
    if mtype == TMessageType.EXCEPTION:
2170 
      x = TApplicationException()
2171 
      x.read(self._iprot)
2172 
      self._iprot.readMessageEnd()
2173 
      raise x
2174 
    result = batchOrders_result()
2175 
    result.read(self._iprot)
2176 
    self._iprot.readMessageEnd()
3431 rajveer 2177 
    if result.success is not None:
1220 chandransh 2178 
      return result.success
3431 rajveer 2179 
    if result.ex is not None:
1220 chandransh 2180 
      raise result.ex
2181 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2182 
 
1208 chandransh 2183 
  def markOrderAsOutOfStock(self, orderId):
2184 
    """
2185 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2186 
 
1208 chandransh 2187 
    Parameters:
2188 
     - orderId
2189 
    """
2190 
    self.send_markOrderAsOutOfStock(orderId)
2191 
    return self.recv_markOrderAsOutOfStock()
2192 
 
2193 
  def send_markOrderAsOutOfStock(self, orderId):
2194 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2195 
    args = markOrderAsOutOfStock_args()
2196 
    args.orderId = orderId
2197 
    args.write(self._oprot)
2198 
    self._oprot.writeMessageEnd()
2199 
    self._oprot.trans.flush()
2200 
 
2201 
  def recv_markOrderAsOutOfStock(self, ):
2202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2203 
    if mtype == TMessageType.EXCEPTION:
2204 
      x = TApplicationException()
2205 
      x.read(self._iprot)
2206 
      self._iprot.readMessageEnd()
2207 
      raise x
2208 
    result = markOrderAsOutOfStock_result()
2209 
    result.read(self._iprot)
2210 
    self._iprot.readMessageEnd()
3431 rajveer 2211 
    if result.success is not None:
1208 chandransh 2212 
      return result.success
3431 rajveer 2213 
    if result.ex is not None:
1208 chandransh 2214 
      raise result.ex
2215 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2216 
 
3064 chandransh 2217 
  def verifyOrder(self, orderId):
759 chandransh 2218 
    """
3064 chandransh 2219 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2220 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2221 
    used for all other orders as well.
2222 
    Throws an exception if no such order exists.
3431 rajveer 2223 
 
759 chandransh 2224 
    Parameters:
3064 chandransh 2225 
     - orderId
759 chandransh 2226 
    """
3064 chandransh 2227 
    self.send_verifyOrder(orderId)
2228 
    return self.recv_verifyOrder()
759 chandransh 2229 
 
3064 chandransh 2230 
  def send_verifyOrder(self, orderId):
2231 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2232 
    args = verifyOrder_args()
2233 
    args.orderId = orderId
759 chandransh 2234 
    args.write(self._oprot)
2235 
    self._oprot.writeMessageEnd()
2236 
    self._oprot.trans.flush()
2237 
 
3064 chandransh 2238 
  def recv_verifyOrder(self, ):
759 chandransh 2239 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2240 
    if mtype == TMessageType.EXCEPTION:
2241 
      x = TApplicationException()
2242 
      x.read(self._iprot)
2243 
      self._iprot.readMessageEnd()
2244 
      raise x
3064 chandransh 2245 
    result = verifyOrder_result()
759 chandransh 2246 
    result.read(self._iprot)
2247 
    self._iprot.readMessageEnd()
3431 rajveer 2248 
    if result.success is not None:
759 chandransh 2249 
      return result.success
3431 rajveer 2250 
    if result.ex is not None:
759 chandransh 2251 
      raise result.ex
3064 chandransh 2252 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2253 
 
3064 chandransh 2254 
  def acceptOrder(self, orderId):
1113 chandransh 2255 
    """
3064 chandransh 2256 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2257 
    given order is not a COD order, it also captures the payment if the same has
2258 
    not been captured.
2259 
    Throws an exception if no such order exists.
3431 rajveer 2260 
 
1113 chandransh 2261 
    Parameters:
3064 chandransh 2262 
     - orderId
1113 chandransh 2263 
    """
3064 chandransh 2264 
    self.send_acceptOrder(orderId)
2265 
    return self.recv_acceptOrder()
1113 chandransh 2266 
 
3064 chandransh 2267 
  def send_acceptOrder(self, orderId):
2268 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2269 
    args = acceptOrder_args()
2270 
    args.orderId = orderId
1113 chandransh 2271 
    args.write(self._oprot)
2272 
    self._oprot.writeMessageEnd()
2273 
    self._oprot.trans.flush()
2274 
 
3064 chandransh 2275 
  def recv_acceptOrder(self, ):
1113 chandransh 2276 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2277 
    if mtype == TMessageType.EXCEPTION:
2278 
      x = TApplicationException()
2279 
      x.read(self._iprot)
2280 
      self._iprot.readMessageEnd()
2281 
      raise x
3064 chandransh 2282 
    result = acceptOrder_result()
1113 chandransh 2283 
    result.read(self._iprot)
2284 
    self._iprot.readMessageEnd()
3431 rajveer 2285 
    if result.success is not None:
1113 chandransh 2286 
      return result.success
3431 rajveer 2287 
    if result.ex is not None:
1113 chandransh 2288 
      raise result.ex
3064 chandransh 2289 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2290 
 
5110 mandeep.dh 2291 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2292 
    """
3064 chandransh 2293 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2294 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2295 
    the IMEI no. if a -1 is supplied.
2296 
    Also, it generates an invoice number for the order, marks the order as
2297 
    BILLED and sets the billing timestamp.
2298 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2299 
 
1135 chandransh 2300 
    Parameters:
3064 chandransh 2301 
     - orderId
2302 
     - invoice_number
4658 mandeep.dh 2303 
     - serialNumber
4283 anupam.sin 2304 
     - itemNumber
3064 chandransh 2305 
     - billed_by
4264 rajveer 2306 
     - jacketNumber
4283 anupam.sin 2307 
     - billingType
5110 mandeep.dh 2308 
     - fulfilmentWarehouseId
4763 rajveer 2309 
     - authorize
1135 chandransh 2310 
    """
5110 mandeep.dh 2311 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2312 
    return self.recv_addBillingDetails()
1135 chandransh 2313 
 
5110 mandeep.dh 2314 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2315 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2316 
    args = addBillingDetails_args()
2317 
    args.orderId = orderId
2318 
    args.invoice_number = invoice_number
4658 mandeep.dh 2319 
    args.serialNumber = serialNumber
4283 anupam.sin 2320 
    args.itemNumber = itemNumber
3064 chandransh 2321 
    args.billed_by = billed_by
4264 rajveer 2322 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2323 
    args.billingType = billingType
5110 mandeep.dh 2324 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2325 
    args.authorize = authorize
1135 chandransh 2326 
    args.write(self._oprot)
2327 
    self._oprot.writeMessageEnd()
2328 
    self._oprot.trans.flush()
2329 
 
3064 chandransh 2330 
  def recv_addBillingDetails(self, ):
1135 chandransh 2331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2332 
    if mtype == TMessageType.EXCEPTION:
2333 
      x = TApplicationException()
2334 
      x.read(self._iprot)
2335 
      self._iprot.readMessageEnd()
2336 
      raise x
3064 chandransh 2337 
    result = addBillingDetails_result()
1135 chandransh 2338 
    result.read(self._iprot)
2339 
    self._iprot.readMessageEnd()
3431 rajveer 2340 
    if result.success is not None:
3064 chandransh 2341 
      return result.success
3431 rajveer 2342 
    if result.ex is not None:
1135 chandransh 2343 
      raise result.ex
3064 chandransh 2344 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2345 
 
4763 rajveer 2346 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2347 
    """
2348 
    Add the invoice number to the order.
2349 
 
2350 
    Parameters:
2351 
     - orderId
2352 
     - invoiceNumber
4763 rajveer 2353 
     - color
4579 rajveer 2354 
    """
4763 rajveer 2355 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2356 
    self.recv_addInvoiceNumber()
2357 
 
4763 rajveer 2358 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2359 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2360 
    args = addInvoiceNumber_args()
2361 
    args.orderId = orderId
2362 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2363 
    args.color = color
4579 rajveer 2364 
    args.write(self._oprot)
2365 
    self._oprot.writeMessageEnd()
2366 
    self._oprot.trans.flush()
2367 
 
2368 
  def recv_addInvoiceNumber(self, ):
2369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2370 
    if mtype == TMessageType.EXCEPTION:
2371 
      x = TApplicationException()
2372 
      x.read(self._iprot)
2373 
      self._iprot.readMessageEnd()
2374 
      raise x
2375 
    result = addInvoiceNumber_result()
2376 
    result.read(self._iprot)
2377 
    self._iprot.readMessageEnd()
2378 
    if result.ex is not None:
2379 
      raise result.ex
2380 
    return
2381 
 
4910 phani.kuma 2382 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2383 
    """
3064 chandransh 2384 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2385 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2386 
 
1408 ankur.sing 2387 
    Parameters:
3064 chandransh 2388 
     - warehouseId
1408 ankur.sing 2389 
     - providerId
3064 chandransh 2390 
     - cod
4910 phani.kuma 2391 
     - orderIds
1408 ankur.sing 2392 
    """
4910 phani.kuma 2393 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2394 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2395 
 
4910 phani.kuma 2396 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2397 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2398 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2399 
    args.warehouseId = warehouseId
1408 ankur.sing 2400 
    args.providerId = providerId
3064 chandransh 2401 
    args.cod = cod
4910 phani.kuma 2402 
    args.orderIds = orderIds
1408 ankur.sing 2403 
    args.write(self._oprot)
2404 
    self._oprot.writeMessageEnd()
2405 
    self._oprot.trans.flush()
2406 
 
4910 phani.kuma 2407 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2409 
    if mtype == TMessageType.EXCEPTION:
2410 
      x = TApplicationException()
2411 
      x.read(self._iprot)
2412 
      self._iprot.readMessageEnd()
2413 
      raise x
4910 phani.kuma 2414 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2415 
    result.read(self._iprot)
2416 
    self._iprot.readMessageEnd()
3431 rajveer 2417 
    if result.success is not None:
1408 ankur.sing 2418 
      return result.success
3431 rajveer 2419 
    if result.ex is not None:
3064 chandransh 2420 
      raise result.ex
4910 phani.kuma 2421 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2422 
 
4910 phani.kuma 2423 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2424 
    """
4910 phani.kuma 2425 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2426 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2427 
 
2428 
    Parameters:
2429 
     - providerId
4910 phani.kuma 2430 
     - pickupDetails
4410 rajveer 2431 
    """
4910 phani.kuma 2432 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2433 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2434 
 
4910 phani.kuma 2435 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2436 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2437 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2438 
    args.providerId = providerId
4910 phani.kuma 2439 
    args.pickupDetails = pickupDetails
4410 rajveer 2440 
    args.write(self._oprot)
2441 
    self._oprot.writeMessageEnd()
2442 
    self._oprot.trans.flush()
2443 
 
4910 phani.kuma 2444 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2445 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2446 
    if mtype == TMessageType.EXCEPTION:
2447 
      x = TApplicationException()
2448 
      x.read(self._iprot)
2449 
      self._iprot.readMessageEnd()
2450 
      raise x
4910 phani.kuma 2451 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2452 
    result.read(self._iprot)
2453 
    self._iprot.readMessageEnd()
2454 
    if result.ex is not None:
2455 
      raise result.ex
4910 phani.kuma 2456 
    return
4410 rajveer 2457 
 
4910 phani.kuma 2458 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2459 
    """
3064 chandransh 2460 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2461 
 
94 ashish 2462 
    Parameters:
3064 chandransh 2463 
     - providerId
304 ashish 2464 
    """
4910 phani.kuma 2465 
    self.send_getOrdersNotPickedUp(providerId)
2466 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2467 
 
4910 phani.kuma 2468 
  def send_getOrdersNotPickedUp(self, providerId):
2469 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2470 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2471 
    args.providerId = providerId
304 ashish 2472 
    args.write(self._oprot)
2473 
    self._oprot.writeMessageEnd()
2474 
    self._oprot.trans.flush()
2475 
 
4910 phani.kuma 2476 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2477 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2478 
    if mtype == TMessageType.EXCEPTION:
2479 
      x = TApplicationException()
2480 
      x.read(self._iprot)
2481 
      self._iprot.readMessageEnd()
2482 
      raise x
4910 phani.kuma 2483 
    result = getOrdersNotPickedUp_result()
304 ashish 2484 
    result.read(self._iprot)
2485 
    self._iprot.readMessageEnd()
3431 rajveer 2486 
    if result.success is not None:
304 ashish 2487 
      return result.success
4910 phani.kuma 2488 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2489 
 
3064 chandransh 2490 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2491 
    """
3064 chandransh 2492 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2493 
    the name of the receiver.
2494 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2495 
 
304 ashish 2496 
    Parameters:
3064 chandransh 2497 
     - providerId
2498 
     - deliveredOrders
304 ashish 2499 
    """
3064 chandransh 2500 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2501 
    self.recv_markOrdersAsDelivered()
304 ashish 2502 
 
3064 chandransh 2503 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2504 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2505 
    args = markOrdersAsDelivered_args()
2506 
    args.providerId = providerId
2507 
    args.deliveredOrders = deliveredOrders
304 ashish 2508 
    args.write(self._oprot)
2509 
    self._oprot.writeMessageEnd()
2510 
    self._oprot.trans.flush()
2511 
 
3064 chandransh 2512 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2513 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2514 
    if mtype == TMessageType.EXCEPTION:
2515 
      x = TApplicationException()
2516 
      x.read(self._iprot)
2517 
      self._iprot.readMessageEnd()
2518 
      raise x
3064 chandransh 2519 
    result = markOrdersAsDelivered_result()
304 ashish 2520 
    result.read(self._iprot)
2521 
    self._iprot.readMessageEnd()
3431 rajveer 2522 
    if result.ex is not None:
3064 chandransh 2523 
      raise result.ex
304 ashish 2524 
    return
2525 
 
4910 phani.kuma 2526 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2527 
    """
4910 phani.kuma 2528 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2529 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2530 
 
3064 chandransh 2531 
    Parameters:
2532 
     - providerId
2533 
     - returnedOrders
1596 ankur.sing 2534 
    """
4910 phani.kuma 2535 
    self.send_markAsRTOrders(providerId, returnedOrders)
2536 
    self.recv_markAsRTOrders()
304 ashish 2537 
 
4910 phani.kuma 2538 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2539 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2540 
    args = markAsRTOrders_args()
3064 chandransh 2541 
    args.providerId = providerId
2542 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2543 
    args.write(self._oprot)
2544 
    self._oprot.writeMessageEnd()
2545 
    self._oprot.trans.flush()
2546 
 
4910 phani.kuma 2547 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2549 
    if mtype == TMessageType.EXCEPTION:
2550 
      x = TApplicationException()
2551 
      x.read(self._iprot)
2552 
      self._iprot.readMessageEnd()
2553 
      raise x
4910 phani.kuma 2554 
    result = markAsRTOrders_result()
1596 ankur.sing 2555 
    result.read(self._iprot)
2556 
    self._iprot.readMessageEnd()
3431 rajveer 2557 
    if result.ex is not None:
3064 chandransh 2558 
      raise result.ex
2559 
    return
1596 ankur.sing 2560 
 
4910 phani.kuma 2561 
  def getRTOrders(self, providerId):
2562 
    """
2563 
    Returns a list of orders that were returned by courier.
2564 
 
2565 
    Parameters:
2566 
     - providerId
2567 
    """
2568 
    self.send_getRTOrders(providerId)
2569 
    return self.recv_getRTOrders()
2570 
 
2571 
  def send_getRTOrders(self, providerId):
2572 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2573 
    args = getRTOrders_args()
2574 
    args.providerId = providerId
2575 
    args.write(self._oprot)
2576 
    self._oprot.writeMessageEnd()
2577 
    self._oprot.trans.flush()
2578 
 
2579 
  def recv_getRTOrders(self, ):
2580 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2581 
    if mtype == TMessageType.EXCEPTION:
2582 
      x = TApplicationException()
2583 
      x.read(self._iprot)
2584 
      self._iprot.readMessageEnd()
2585 
      raise x
2586 
    result = getRTOrders_result()
2587 
    result.read(self._iprot)
2588 
    self._iprot.readMessageEnd()
2589 
    if result.success is not None:
2590 
      return result.success
2591 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2592 
 
3064 chandransh 2593 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2594 
    """
3064 chandransh 2595 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2596 
 
3064 chandransh 2597 
    Parameters:
2598 
     - providerId
2599 
     - undeliveredOrders
1627 ankur.sing 2600 
    """
3064 chandransh 2601 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2602 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2603 
 
3064 chandransh 2604 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2605 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2606 
    args = updateNonDeliveryReason_args()
2607 
    args.providerId = providerId
2608 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2609 
    args.write(self._oprot)
2610 
    self._oprot.writeMessageEnd()
2611 
    self._oprot.trans.flush()
2612 
 
3064 chandransh 2613 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2614 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2615 
    if mtype == TMessageType.EXCEPTION:
2616 
      x = TApplicationException()
2617 
      x.read(self._iprot)
2618 
      self._iprot.readMessageEnd()
2619 
      raise x
3064 chandransh 2620 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2621 
    result.read(self._iprot)
2622 
    self._iprot.readMessageEnd()
4910 phani.kuma 2623 
    if result.ex is not None:
2624 
      raise result.ex
2625 
    return
2626 
 
2627 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2628 
    """
2629 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2630 
 
2631 
    Parameters:
2632 
     - providerId
2633 
    """
2634 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2635 
    return self.recv_getNonDeliveredOrdersbyCourier()
2636 
 
2637 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2638 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2639 
    args = getNonDeliveredOrdersbyCourier_args()
2640 
    args.providerId = providerId
2641 
    args.write(self._oprot)
2642 
    self._oprot.writeMessageEnd()
2643 
    self._oprot.trans.flush()
2644 
 
2645 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2646 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2647 
    if mtype == TMessageType.EXCEPTION:
2648 
      x = TApplicationException()
2649 
      x.read(self._iprot)
2650 
      self._iprot.readMessageEnd()
2651 
      raise x
2652 
    result = getNonDeliveredOrdersbyCourier_result()
2653 
    result.read(self._iprot)
2654 
    self._iprot.readMessageEnd()
4581 phani.kuma 2655 
    if result.success is not None:
2656 
      return result.success
4910 phani.kuma 2657 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2658 
 
2659 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2660 
    """
2661 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2662 
 
2663 
    Parameters:
2664 
     - providerId
2665 
     - local_connected_orders
2666 
    """
2667 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2668 
    self.recv_markOrdersAsLocalConnected()
2669 
 
2670 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2671 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2672 
    args = markOrdersAsLocalConnected_args()
2673 
    args.providerId = providerId
2674 
    args.local_connected_orders = local_connected_orders
2675 
    args.write(self._oprot)
2676 
    self._oprot.writeMessageEnd()
2677 
    self._oprot.trans.flush()
2678 
 
2679 
  def recv_markOrdersAsLocalConnected(self, ):
2680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2681 
    if mtype == TMessageType.EXCEPTION:
2682 
      x = TApplicationException()
2683 
      x.read(self._iprot)
2684 
      self._iprot.readMessageEnd()
2685 
      raise x
2686 
    result = markOrdersAsLocalConnected_result()
2687 
    result.read(self._iprot)
2688 
    self._iprot.readMessageEnd()
3431 rajveer 2689 
    if result.ex is not None:
3064 chandransh 2690 
      raise result.ex
4910 phani.kuma 2691 
    return
1627 ankur.sing 2692 
 
4910 phani.kuma 2693 
  def getOrdersNotLocalConnected(self, providerId):
2694 
    """
2695 
    Returns a list of orders that were picked up or shipped but pending local connection.
2696 
 
2697 
    Parameters:
2698 
     - providerId
2699 
    """
2700 
    self.send_getOrdersNotLocalConnected(providerId)
2701 
    return self.recv_getOrdersNotLocalConnected()
2702 
 
2703 
  def send_getOrdersNotLocalConnected(self, providerId):
2704 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2705 
    args = getOrdersNotLocalConnected_args()
2706 
    args.providerId = providerId
2707 
    args.write(self._oprot)
2708 
    self._oprot.writeMessageEnd()
2709 
    self._oprot.trans.flush()
2710 
 
2711 
  def recv_getOrdersNotLocalConnected(self, ):
2712 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2713 
    if mtype == TMessageType.EXCEPTION:
2714 
      x = TApplicationException()
2715 
      x.read(self._iprot)
2716 
      self._iprot.readMessageEnd()
2717 
      raise x
2718 
    result = getOrdersNotLocalConnected_result()
2719 
    result.read(self._iprot)
2720 
    self._iprot.readMessageEnd()
2721 
    if result.success is not None:
2722 
      return result.success
2723 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2724 
 
2725 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2726 
    """
2727 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2728 
 
2729 
    Parameters:
2730 
     - providerId
2731 
     - destination_city_reached_orders
2732 
    """
2733 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2734 
    self.recv_markOrdersAsDestinationCityReached()
2735 
 
2736 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2737 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2738 
    args = markOrdersAsDestinationCityReached_args()
2739 
    args.providerId = providerId
2740 
    args.destination_city_reached_orders = destination_city_reached_orders
2741 
    args.write(self._oprot)
2742 
    self._oprot.writeMessageEnd()
2743 
    self._oprot.trans.flush()
2744 
 
2745 
  def recv_markOrdersAsDestinationCityReached(self, ):
2746 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2747 
    if mtype == TMessageType.EXCEPTION:
2748 
      x = TApplicationException()
2749 
      x.read(self._iprot)
2750 
      self._iprot.readMessageEnd()
2751 
      raise x
2752 
    result = markOrdersAsDestinationCityReached_result()
2753 
    result.read(self._iprot)
2754 
    self._iprot.readMessageEnd()
2755 
    if result.ex is not None:
2756 
      raise result.ex
2757 
    return
2758 
 
2759 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2760 
    """
2761 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
2762 
 
2763 
    Parameters:
2764 
     - providerId
2765 
     - first_atdl_orders
2766 
    """
2767 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
2768 
    self.recv_markOrdersAsFirstDeliveryAttempted()
2769 
 
2770 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2771 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
2772 
    args = markOrdersAsFirstDeliveryAttempted_args()
2773 
    args.providerId = providerId
2774 
    args.first_atdl_orders = first_atdl_orders
2775 
    args.write(self._oprot)
2776 
    self._oprot.writeMessageEnd()
2777 
    self._oprot.trans.flush()
2778 
 
2779 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
2780 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2781 
    if mtype == TMessageType.EXCEPTION:
2782 
      x = TApplicationException()
2783 
      x.read(self._iprot)
2784 
      self._iprot.readMessageEnd()
2785 
      raise x
2786 
    result = markOrdersAsFirstDeliveryAttempted_result()
2787 
    result.read(self._iprot)
2788 
    self._iprot.readMessageEnd()
2789 
    if result.ex is not None:
2790 
      raise result.ex
2791 
    return
2792 
 
3064 chandransh 2793 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2794 
    """
3064 chandransh 2795 
    Returns the list of orders whose delivery time has passed but have not been
2796 
    delivered yet for the given provider and warehouse. To get a complete list of
2797 
    undelivered orders, pass them as -1.
2798 
    Returns an empty list if no such orders exist.
3431 rajveer 2799 
 
1886 ankur.sing 2800 
    Parameters:
3064 chandransh 2801 
     - providerId
2802 
     - warehouseId
1886 ankur.sing 2803 
    """
3064 chandransh 2804 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2805 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2806 
 
3064 chandransh 2807 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2808 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2809 
    args = getUndeliveredOrders_args()
2810 
    args.providerId = providerId
2811 
    args.warehouseId = warehouseId
1886 ankur.sing 2812 
    args.write(self._oprot)
2813 
    self._oprot.writeMessageEnd()
2814 
    self._oprot.trans.flush()
2815 
 
3064 chandransh 2816 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2818 
    if mtype == TMessageType.EXCEPTION:
2819 
      x = TApplicationException()
2820 
      x.read(self._iprot)
2821 
      self._iprot.readMessageEnd()
2822 
      raise x
3064 chandransh 2823 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2824 
    result.read(self._iprot)
2825 
    self._iprot.readMessageEnd()
3431 rajveer 2826 
    if result.success is not None:
1886 ankur.sing 2827 
      return result.success
3064 chandransh 2828 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2829 
 
4783 phani.kuma 2830 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2831 
    """
2832 
    Returns the list of orders whose expected delivery date has passed but have not been
2833 
    delivered yet.
2834 
    Returns an empty list if no such orders exist.
2835 
    """
2836 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2837 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2838 
 
2839 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2840 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2841 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2842 
    args.write(self._oprot)
2843 
    self._oprot.writeMessageEnd()
2844 
    self._oprot.trans.flush()
2845 
 
2846 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2847 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2848 
    if mtype == TMessageType.EXCEPTION:
2849 
      x = TApplicationException()
2850 
      x.read(self._iprot)
2851 
      self._iprot.readMessageEnd()
2852 
      raise x
2853 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2854 
    result.read(self._iprot)
2855 
    self._iprot.readMessageEnd()
2856 
    if result.success is not None:
2857 
      return result.success
2858 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2859 
 
2536 chandransh 2860 
  def toggleDOAFlag(self, orderId):
2861 
    """
2862 
    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.
2863 
    Returns the final flag status.
2864 
    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 2865 
 
2536 chandransh 2866 
    Parameters:
2867 
     - orderId
2868 
    """
2869 
    self.send_toggleDOAFlag(orderId)
2870 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2871 
 
2536 chandransh 2872 
  def send_toggleDOAFlag(self, orderId):
2873 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2874 
    args = toggleDOAFlag_args()
2875 
    args.orderId = orderId
2876 
    args.write(self._oprot)
2877 
    self._oprot.writeMessageEnd()
2878 
    self._oprot.trans.flush()
2879 
 
2880 
  def recv_toggleDOAFlag(self, ):
2881 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2882 
    if mtype == TMessageType.EXCEPTION:
2883 
      x = TApplicationException()
2884 
      x.read(self._iprot)
2885 
      self._iprot.readMessageEnd()
2886 
      raise x
2887 
    result = toggleDOAFlag_result()
2888 
    result.read(self._iprot)
2889 
    self._iprot.readMessageEnd()
3431 rajveer 2890 
    if result.success is not None:
2536 chandransh 2891 
      return result.success
3431 rajveer 2892 
    if result.ex is not None:
2536 chandransh 2893 
      raise result.ex
2894 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2895 
 
4712 rajveer 2896 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2897 
    """
2898 
    Parameters:
2899 
     - orderId
2900 
     - deliveryTimestamp
2901 
     - receiver
2902 
    """
2903 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2904 
    self.recv_markOrderAsDelivered()
2905 
 
2906 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2907 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2908 
    args = markOrderAsDelivered_args()
2909 
    args.orderId = orderId
2910 
    args.deliveryTimestamp = deliveryTimestamp
2911 
    args.receiver = receiver
2912 
    args.write(self._oprot)
2913 
    self._oprot.writeMessageEnd()
2914 
    self._oprot.trans.flush()
2915 
 
2916 
  def recv_markOrderAsDelivered(self, ):
2917 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2918 
    if mtype == TMessageType.EXCEPTION:
2919 
      x = TApplicationException()
2920 
      x.read(self._iprot)
2921 
      self._iprot.readMessageEnd()
2922 
      raise x
2923 
    result = markOrderAsDelivered_result()
2924 
    result.read(self._iprot)
2925 
    self._iprot.readMessageEnd()
2926 
    if result.ex is not None:
2927 
      raise result.ex
2928 
    return
2929 
 
4454 rajveer 2930 
  def markOrderDoaRequestReceived(self, orderId):
2931 
    """
2932 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2933 
 
2934 
    Parameters:
2935 
     - orderId
2936 
    """
2937 
    self.send_markOrderDoaRequestReceived(orderId)
2938 
    return self.recv_markOrderDoaRequestReceived()
2939 
 
2940 
  def send_markOrderDoaRequestReceived(self, orderId):
2941 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2942 
    args = markOrderDoaRequestReceived_args()
2943 
    args.orderId = orderId
2944 
    args.write(self._oprot)
2945 
    self._oprot.writeMessageEnd()
2946 
    self._oprot.trans.flush()
2947 
 
2948 
  def recv_markOrderDoaRequestReceived(self, ):
2949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2950 
    if mtype == TMessageType.EXCEPTION:
2951 
      x = TApplicationException()
2952 
      x.read(self._iprot)
2953 
      self._iprot.readMessageEnd()
2954 
      raise x
2955 
    result = markOrderDoaRequestReceived_result()
2956 
    result.read(self._iprot)
2957 
    self._iprot.readMessageEnd()
2958 
    if result.success is not None:
2959 
      return result.success
2960 
    if result.ex is not None:
2961 
      raise result.ex
2962 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2963 
 
2964 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2965 
    """
2966 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2967 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2968 
 
2969 
    Parameters:
2970 
     - orderId
2971 
     - isAuthorized
2972 
    """
2973 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2974 
    return self.recv_markOrderDoaRequestAuthorized()
2975 
 
2976 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2977 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2978 
    args = markOrderDoaRequestAuthorized_args()
2979 
    args.orderId = orderId
2980 
    args.isAuthorized = isAuthorized
2981 
    args.write(self._oprot)
2982 
    self._oprot.writeMessageEnd()
2983 
    self._oprot.trans.flush()
2984 
 
2985 
  def recv_markOrderDoaRequestAuthorized(self, ):
2986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2987 
    if mtype == TMessageType.EXCEPTION:
2988 
      x = TApplicationException()
2989 
      x.read(self._iprot)
2990 
      self._iprot.readMessageEnd()
2991 
      raise x
2992 
    result = markOrderDoaRequestAuthorized_result()
2993 
    result.read(self._iprot)
2994 
    self._iprot.readMessageEnd()
2995 
    if result.success is not None:
2996 
      return result.success
2997 
    if result.ex is not None:
2998 
      raise result.ex
2999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3000 
 
4488 rajveer 3001 
  def markOrderReturnRequestReceived(self, orderId):
3002 
    """
3003 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3004 
 
3005 
    Parameters:
3006 
     - orderId
3007 
    """
3008 
    self.send_markOrderReturnRequestReceived(orderId)
3009 
    return self.recv_markOrderReturnRequestReceived()
3010 
 
3011 
  def send_markOrderReturnRequestReceived(self, orderId):
3012 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3013 
    args = markOrderReturnRequestReceived_args()
3014 
    args.orderId = orderId
3015 
    args.write(self._oprot)
3016 
    self._oprot.writeMessageEnd()
3017 
    self._oprot.trans.flush()
3018 
 
3019 
  def recv_markOrderReturnRequestReceived(self, ):
3020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3021 
    if mtype == TMessageType.EXCEPTION:
3022 
      x = TApplicationException()
3023 
      x.read(self._iprot)
3024 
      self._iprot.readMessageEnd()
3025 
      raise x
3026 
    result = markOrderReturnRequestReceived_result()
3027 
    result.read(self._iprot)
3028 
    self._iprot.readMessageEnd()
3029 
    if result.success is not None:
3030 
      return result.success
3031 
    if result.ex is not None:
3032 
      raise result.ex
3033 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3034 
 
3035 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3036 
    """
3037 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3038 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3039 
 
3040 
    Parameters:
3041 
     - orderId
3042 
     - isAuthorized
3043 
    """
3044 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3045 
    return self.recv_markOrderReturnRequestAuthorized()
3046 
 
3047 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3048 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3049 
    args = markOrderReturnRequestAuthorized_args()
3050 
    args.orderId = orderId
3051 
    args.isAuthorized = isAuthorized
3052 
    args.write(self._oprot)
3053 
    self._oprot.writeMessageEnd()
3054 
    self._oprot.trans.flush()
3055 
 
3056 
  def recv_markOrderReturnRequestAuthorized(self, ):
3057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3058 
    if mtype == TMessageType.EXCEPTION:
3059 
      x = TApplicationException()
3060 
      x.read(self._iprot)
3061 
      self._iprot.readMessageEnd()
3062 
      raise x
3063 
    result = markOrderReturnRequestAuthorized_result()
3064 
    result.read(self._iprot)
3065 
    self._iprot.readMessageEnd()
3066 
    if result.success is not None:
3067 
      return result.success
3068 
    if result.ex is not None:
3069 
      raise result.ex
3070 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3071 
 
4579 rajveer 3072 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3073 
    """
3074 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3075 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3076 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3077 
    For any other status, it returns false.
3078 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3079 
 
2536 chandransh 3080 
    Parameters:
3081 
     - orderId
4579 rajveer 3082 
     - providerId
2536 chandransh 3083 
    """
4579 rajveer 3084 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3085 
    return self.recv_requestPickupNumber()
3086 
 
4579 rajveer 3087 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3088 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3089 
    args = requestPickupNumber_args()
3090 
    args.orderId = orderId
4579 rajveer 3091 
    args.providerId = providerId
2536 chandransh 3092 
    args.write(self._oprot)
3093 
    self._oprot.writeMessageEnd()
3094 
    self._oprot.trans.flush()
3095 
 
3096 
  def recv_requestPickupNumber(self, ):
3097 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3098 
    if mtype == TMessageType.EXCEPTION:
3099 
      x = TApplicationException()
3100 
      x.read(self._iprot)
3101 
      self._iprot.readMessageEnd()
3102 
      raise x
3103 
    result = requestPickupNumber_result()
3104 
    result.read(self._iprot)
3105 
    self._iprot.readMessageEnd()
3431 rajveer 3106 
    if result.success is not None:
2536 chandransh 3107 
      return result.success
3431 rajveer 3108 
    if result.ex is not None:
2536 chandransh 3109 
      raise result.ex
3110 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3111 
 
4602 rajveer 3112 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3113 
    """
4452 rajveer 3114 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3115 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3116 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3117 
    	3. Returns true
2591 chandransh 3118 
    If the order is in any other status, it returns false.
2536 chandransh 3119 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3120 
 
2536 chandransh 3121 
    Parameters:
3122 
     - orderId
3123 
     - pickupNumber
4602 rajveer 3124 
     - providerId
2536 chandransh 3125 
    """
4602 rajveer 3126 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3127 
    return self.recv_authorizePickup()
3128 
 
4602 rajveer 3129 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3130 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3131 
    args = authorizePickup_args()
3132 
    args.orderId = orderId
3133 
    args.pickupNumber = pickupNumber
4602 rajveer 3134 
    args.providerId = providerId
2536 chandransh 3135 
    args.write(self._oprot)
3136 
    self._oprot.writeMessageEnd()
3137 
    self._oprot.trans.flush()
3138 
 
3139 
  def recv_authorizePickup(self, ):
3140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3141 
    if mtype == TMessageType.EXCEPTION:
3142 
      x = TApplicationException()
3143 
      x.read(self._iprot)
3144 
      self._iprot.readMessageEnd()
3145 
      raise x
3146 
    result = authorizePickup_result()
3147 
    result.read(self._iprot)
3148 
    self._iprot.readMessageEnd()
3431 rajveer 3149 
    if result.success is not None:
2536 chandransh 3150 
      return result.success
3431 rajveer 3151 
    if result.ex is not None:
2536 chandransh 3152 
      raise result.ex
3153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3154 
 
2764 chandransh 3155 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3156 
    """
3157 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3158 
 
2764 chandransh 3159 
    Parameters:
3160 
     - providerId
3161 
     - pickupDetails
3162 
    """
3163 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3164 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3165 
 
3166 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3167 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3168 
    args = markDoasAsPickedUp_args()
3169 
    args.providerId = providerId
3170 
    args.pickupDetails = pickupDetails
3171 
    args.write(self._oprot)
3172 
    self._oprot.writeMessageEnd()
3173 
    self._oprot.trans.flush()
3174 
 
3175 
  def recv_markDoasAsPickedUp(self, ):
3176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3177 
    if mtype == TMessageType.EXCEPTION:
3178 
      x = TApplicationException()
3179 
      x.read(self._iprot)
3180 
      self._iprot.readMessageEnd()
3181 
      raise x
3182 
    result = markDoasAsPickedUp_result()
3183 
    result.read(self._iprot)
3184 
    self._iprot.readMessageEnd()
4910 phani.kuma 3185 
    return
3186 
 
3187 
  def getDoasNotPickedUp(self, providerId):
3188 
    """
3189 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3190 
 
3191 
    Parameters:
3192 
     - providerId
3193 
    """
3194 
    self.send_getDoasNotPickedUp(providerId)
3195 
    return self.recv_getDoasNotPickedUp()
3196 
 
3197 
  def send_getDoasNotPickedUp(self, providerId):
3198 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3199 
    args = getDoasNotPickedUp_args()
3200 
    args.providerId = providerId
3201 
    args.write(self._oprot)
3202 
    self._oprot.writeMessageEnd()
3203 
    self._oprot.trans.flush()
3204 
 
3205 
  def recv_getDoasNotPickedUp(self, ):
3206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3207 
    if mtype == TMessageType.EXCEPTION:
3208 
      x = TApplicationException()
3209 
      x.read(self._iprot)
3210 
      self._iprot.readMessageEnd()
3211 
      raise x
3212 
    result = getDoasNotPickedUp_result()
3213 
    result.read(self._iprot)
3214 
    self._iprot.readMessageEnd()
3431 rajveer 3215 
    if result.success is not None:
2764 chandransh 3216 
      return result.success
4910 phani.kuma 3217 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3218 
 
4741 phani.kuma 3219 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3220 
    """
3221 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3222 
 
3223 
    Parameters:
3224 
     - providerId
3225 
     - pickupDetails
3226 
    """
3227 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3228 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3229 
 
3230 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3231 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3232 
    args = markReturnOrdersAsPickedUp_args()
3233 
    args.providerId = providerId
3234 
    args.pickupDetails = pickupDetails
3235 
    args.write(self._oprot)
3236 
    self._oprot.writeMessageEnd()
3237 
    self._oprot.trans.flush()
3238 
 
3239 
  def recv_markReturnOrdersAsPickedUp(self, ):
3240 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3241 
    if mtype == TMessageType.EXCEPTION:
3242 
      x = TApplicationException()
3243 
      x.read(self._iprot)
3244 
      self._iprot.readMessageEnd()
3245 
      raise x
3246 
    result = markReturnOrdersAsPickedUp_result()
3247 
    result.read(self._iprot)
3248 
    self._iprot.readMessageEnd()
4910 phani.kuma 3249 
    return
3250 
 
3251 
  def getReturnOrdersNotPickedUp(self, providerId):
3252 
    """
3253 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3254 
 
3255 
    Parameters:
3256 
     - providerId
3257 
    """
3258 
    self.send_getReturnOrdersNotPickedUp(providerId)
3259 
    return self.recv_getReturnOrdersNotPickedUp()
3260 
 
3261 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3262 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3263 
    args = getReturnOrdersNotPickedUp_args()
3264 
    args.providerId = providerId
3265 
    args.write(self._oprot)
3266 
    self._oprot.writeMessageEnd()
3267 
    self._oprot.trans.flush()
3268 
 
3269 
  def recv_getReturnOrdersNotPickedUp(self, ):
3270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3271 
    if mtype == TMessageType.EXCEPTION:
3272 
      x = TApplicationException()
3273 
      x.read(self._iprot)
3274 
      self._iprot.readMessageEnd()
3275 
      raise x
3276 
    result = getReturnOrdersNotPickedUp_result()
3277 
    result.read(self._iprot)
3278 
    self._iprot.readMessageEnd()
4741 phani.kuma 3279 
    if result.success is not None:
3280 
      return result.success
4910 phani.kuma 3281 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3282 
 
4479 rajveer 3283 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3284 
    """
4452 rajveer 3285 
    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 3286 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3287 
    If the order is in any other state, it returns false.
3288 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3289 
 
2591 chandransh 3290 
    Parameters:
3291 
     - orderId
4479 rajveer 3292 
     - receiveCondition
2591 chandransh 3293 
    """
4479 rajveer 3294 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3295 
    return self.recv_receiveReturn()
2536 chandransh 3296 
 
4479 rajveer 3297 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3298 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3299 
    args = receiveReturn_args()
2591 chandransh 3300 
    args.orderId = orderId
4479 rajveer 3301 
    args.receiveCondition = receiveCondition
2591 chandransh 3302 
    args.write(self._oprot)
3303 
    self._oprot.writeMessageEnd()
3304 
    self._oprot.trans.flush()
3305 
 
2616 chandransh 3306 
  def recv_receiveReturn(self, ):
2591 chandransh 3307 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3308 
    if mtype == TMessageType.EXCEPTION:
3309 
      x = TApplicationException()
3310 
      x.read(self._iprot)
3311 
      self._iprot.readMessageEnd()
3312 
      raise x
2616 chandransh 3313 
    result = receiveReturn_result()
2591 chandransh 3314 
    result.read(self._iprot)
3315 
    self._iprot.readMessageEnd()
3431 rajveer 3316 
    if result.success is not None:
2591 chandransh 3317 
      return result.success
3431 rajveer 3318 
    if result.ex is not None:
2591 chandransh 3319 
      raise result.ex
2616 chandransh 3320 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3321 
 
3322 
  def validateDoa(self, orderId, isValid):
3323 
    """
4452 rajveer 3324 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3325 
    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 3326 
    If the order is in any other state, it returns false.
3327 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3328 
 
2591 chandransh 3329 
    Parameters:
3330 
     - orderId
3331 
     - isValid
3332 
    """
3333 
    self.send_validateDoa(orderId, isValid)
3334 
    return self.recv_validateDoa()
3335 
 
3336 
  def send_validateDoa(self, orderId, isValid):
3337 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3338 
    args = validateDoa_args()
3339 
    args.orderId = orderId
3340 
    args.isValid = isValid
3341 
    args.write(self._oprot)
3342 
    self._oprot.writeMessageEnd()
3343 
    self._oprot.trans.flush()
3344 
 
3345 
  def recv_validateDoa(self, ):
3346 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3347 
    if mtype == TMessageType.EXCEPTION:
3348 
      x = TApplicationException()
3349 
      x.read(self._iprot)
3350 
      self._iprot.readMessageEnd()
3351 
      raise x
3352 
    result = validateDoa_result()
3353 
    result.read(self._iprot)
3354 
    self._iprot.readMessageEnd()
3431 rajveer 3355 
    if result.success is not None:
2591 chandransh 3356 
      return result.success
3431 rajveer 3357 
    if result.ex is not None:
2591 chandransh 3358 
      raise result.ex
3359 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3360 
 
4495 rajveer 3361 
  def validateReturnProduct(self, orderId, isUsable):
3362 
    """
3363 
    Parameters:
3364 
     - orderId
3365 
     - isUsable
3366 
    """
3367 
    self.send_validateReturnProduct(orderId, isUsable)
3368 
    return self.recv_validateReturnProduct()
3369 
 
3370 
  def send_validateReturnProduct(self, orderId, isUsable):
3371 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3372 
    args = validateReturnProduct_args()
3373 
    args.orderId = orderId
3374 
    args.isUsable = isUsable
3375 
    args.write(self._oprot)
3376 
    self._oprot.writeMessageEnd()
3377 
    self._oprot.trans.flush()
3378 
 
3379 
  def recv_validateReturnProduct(self, ):
3380 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3381 
    if mtype == TMessageType.EXCEPTION:
3382 
      x = TApplicationException()
3383 
      x.read(self._iprot)
3384 
      self._iprot.readMessageEnd()
3385 
      raise x
3386 
    result = validateReturnProduct_result()
3387 
    result.read(self._iprot)
3388 
    self._iprot.readMessageEnd()
3389 
    if result.success is not None:
3390 
      return result.success
3391 
    if result.ex is not None:
3392 
      raise result.ex
3393 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3394 
 
2616 chandransh 3395 
  def reshipOrder(self, orderId):
3396 
    """
4484 rajveer 3397 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3398 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3399 
    	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 3400 
 
3401 
    If the order is in DOA_CERT_VALID state, it does the following:
3402 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3403 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3404 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3405 
 
2616 chandransh 3406 
    Returns the id of the newly created order.
3431 rajveer 3407 
 
2616 chandransh 3408 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3409 
 
2616 chandransh 3410 
    Parameters:
3411 
     - orderId
3412 
    """
3413 
    self.send_reshipOrder(orderId)
3414 
    return self.recv_reshipOrder()
2591 chandransh 3415 
 
2616 chandransh 3416 
  def send_reshipOrder(self, orderId):
3417 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3418 
    args = reshipOrder_args()
3419 
    args.orderId = orderId
3420 
    args.write(self._oprot)
3421 
    self._oprot.writeMessageEnd()
3422 
    self._oprot.trans.flush()
3423 
 
3424 
  def recv_reshipOrder(self, ):
3425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3426 
    if mtype == TMessageType.EXCEPTION:
3427 
      x = TApplicationException()
3428 
      x.read(self._iprot)
3429 
      self._iprot.readMessageEnd()
3430 
      raise x
3431 
    result = reshipOrder_result()
3432 
    result.read(self._iprot)
3433 
    self._iprot.readMessageEnd()
3431 rajveer 3434 
    if result.success is not None:
2616 chandransh 3435 
      return result.success
3431 rajveer 3436 
    if result.ex is not None:
2616 chandransh 3437 
      raise result.ex
3438 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3439 
 
3226 chandransh 3440 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3441 
    """
4484 rajveer 3442 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3443 
    	1. Creates a refund request for batch processing.
3444 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3445 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3446 
 
2616 chandransh 3447 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3448 
    	1. Creates a refund request for batch processing.
3226 chandransh 3449 
    	2. Cancels the reservation of the item in the warehouse.
3450 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3451 
 
3226 chandransh 3452 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3453 
    	1. Cancels the reservation of the item in the warehouse.
3454 
    	2. Marks the current order as CANCELED.
3455 
 
3456 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3457 
 
2616 chandransh 3458 
    Returns True if it is successful, False otherwise.
3431 rajveer 3459 
 
2616 chandransh 3460 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3461 
 
2616 chandransh 3462 
    Parameters:
3463 
     - orderId
3226 chandransh 3464 
     - refundedBy
3465 
     - reason
2616 chandransh 3466 
    """
3226 chandransh 3467 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3468 
    return self.recv_refundOrder()
3469 
 
3226 chandransh 3470 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3471 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3472 
    args = refundOrder_args()
3473 
    args.orderId = orderId
3226 chandransh 3474 
    args.refundedBy = refundedBy
3475 
    args.reason = reason
2616 chandransh 3476 
    args.write(self._oprot)
3477 
    self._oprot.writeMessageEnd()
3478 
    self._oprot.trans.flush()
3479 
 
3480 
  def recv_refundOrder(self, ):
3481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3482 
    if mtype == TMessageType.EXCEPTION:
3483 
      x = TApplicationException()
3484 
      x.read(self._iprot)
3485 
      self._iprot.readMessageEnd()
3486 
      raise x
3487 
    result = refundOrder_result()
3488 
    result.read(self._iprot)
3489 
    self._iprot.readMessageEnd()
3431 rajveer 3490 
    if result.success is not None:
2616 chandransh 3491 
      return result.success
3431 rajveer 3492 
    if result.ex is not None:
2616 chandransh 3493 
      raise result.ex
3494 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3495 
 
2690 chandransh 3496 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3497 
    """
3498 
    Get all return orders created between the from and to dates for the given warehouse.
3499 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3500 
 
2690 chandransh 3501 
    Parameters:
3502 
     - warehouseId
3503 
     - fromDate
3504 
     - toDate
3505 
    """
3506 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3507 
    return self.recv_getReturnOrders()
2616 chandransh 3508 
 
2690 chandransh 3509 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3510 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3511 
    args = getReturnOrders_args()
3512 
    args.warehouseId = warehouseId
3513 
    args.fromDate = fromDate
3514 
    args.toDate = toDate
3515 
    args.write(self._oprot)
3516 
    self._oprot.writeMessageEnd()
3517 
    self._oprot.trans.flush()
3518 
 
3519 
  def recv_getReturnOrders(self, ):
3520 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3521 
    if mtype == TMessageType.EXCEPTION:
3522 
      x = TApplicationException()
3523 
      x.read(self._iprot)
3524 
      self._iprot.readMessageEnd()
3525 
      raise x
3526 
    result = getReturnOrders_result()
3527 
    result.read(self._iprot)
3528 
    self._iprot.readMessageEnd()
3431 rajveer 3529 
    if result.success is not None:
2690 chandransh 3530 
      return result.success
3531 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3532 
 
2700 chandransh 3533 
  def getReturnOrder(self, id):
3534 
    """
3535 
    Returns the ReturnOrder corresponding to the given id.
3536 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3537 
 
2700 chandransh 3538 
    Parameters:
3539 
     - id
3540 
    """
3541 
    self.send_getReturnOrder(id)
3542 
    return self.recv_getReturnOrder()
3543 
 
3544 
  def send_getReturnOrder(self, id):
3545 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3546 
    args = getReturnOrder_args()
3547 
    args.id = id
3548 
    args.write(self._oprot)
3549 
    self._oprot.writeMessageEnd()
3550 
    self._oprot.trans.flush()
3551 
 
3552 
  def recv_getReturnOrder(self, ):
3553 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3554 
    if mtype == TMessageType.EXCEPTION:
3555 
      x = TApplicationException()
3556 
      x.read(self._iprot)
3557 
      self._iprot.readMessageEnd()
3558 
      raise x
3559 
    result = getReturnOrder_result()
3560 
    result.read(self._iprot)
3561 
    self._iprot.readMessageEnd()
3431 rajveer 3562 
    if result.success is not None:
2700 chandransh 3563 
      return result.success
3431 rajveer 3564 
    if result.ex is not None:
2700 chandransh 3565 
      raise result.ex
3566 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3567 
 
2690 chandransh 3568 
  def processReturn(self, returnOrderId):
3569 
    """
3570 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3571 
 
2690 chandransh 3572 
    Parameters:
3573 
     - returnOrderId
3574 
    """
3575 
    self.send_processReturn(returnOrderId)
3576 
    self.recv_processReturn()
3577 
 
3578 
  def send_processReturn(self, returnOrderId):
3579 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3580 
    args = processReturn_args()
3581 
    args.returnOrderId = returnOrderId
3582 
    args.write(self._oprot)
3583 
    self._oprot.writeMessageEnd()
3584 
    self._oprot.trans.flush()
3585 
 
3586 
  def recv_processReturn(self, ):
3587 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3588 
    if mtype == TMessageType.EXCEPTION:
3589 
      x = TApplicationException()
3590 
      x.read(self._iprot)
3591 
      self._iprot.readMessageEnd()
3592 
      raise x
3593 
    result = processReturn_result()
3594 
    result.read(self._iprot)
3595 
    self._iprot.readMessageEnd()
3431 rajveer 3596 
    if result.ex is not None:
2690 chandransh 3597 
      raise result.ex
3598 
    return
3599 
 
3451 chandransh 3600 
  def updateWeight(self, orderId, weight):
3601 
    """
3602 
    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 3603 
 
3451 chandransh 3604 
    Parameters:
3605 
     - orderId
3606 
     - weight
3607 
    """
3608 
    self.send_updateWeight(orderId, weight)
3609 
    return self.recv_updateWeight()
3610 
 
3611 
  def send_updateWeight(self, orderId, weight):
3612 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3613 
    args = updateWeight_args()
3614 
    args.orderId = orderId
3615 
    args.weight = weight
3616 
    args.write(self._oprot)
3617 
    self._oprot.writeMessageEnd()
3618 
    self._oprot.trans.flush()
3619 
 
3620 
  def recv_updateWeight(self, ):
3621 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3622 
    if mtype == TMessageType.EXCEPTION:
3623 
      x = TApplicationException()
3624 
      x.read(self._iprot)
3625 
      self._iprot.readMessageEnd()
3626 
      raise x
3627 
    result = updateWeight_result()
3628 
    result.read(self._iprot)
3629 
    self._iprot.readMessageEnd()
3630 
    if result.success is not None:
3631 
      return result.success
3632 
    if result.ex is not None:
3633 
      raise result.ex
3634 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3635 
 
3469 chandransh 3636 
  def changeItem(self, orderId, itemId):
3637 
    """
3638 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3639 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3640 
 
3469 chandransh 3641 
    Parameters:
3642 
     - orderId
3643 
     - itemId
3644 
    """
3645 
    self.send_changeItem(orderId, itemId)
3646 
    return self.recv_changeItem()
3647 
 
3648 
  def send_changeItem(self, orderId, itemId):
3649 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3650 
    args = changeItem_args()
3651 
    args.orderId = orderId
3652 
    args.itemId = itemId
3653 
    args.write(self._oprot)
3654 
    self._oprot.writeMessageEnd()
3655 
    self._oprot.trans.flush()
3656 
 
3657 
  def recv_changeItem(self, ):
3658 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3659 
    if mtype == TMessageType.EXCEPTION:
3660 
      x = TApplicationException()
3661 
      x.read(self._iprot)
3662 
      self._iprot.readMessageEnd()
3663 
      raise x
3664 
    result = changeItem_result()
3665 
    result.read(self._iprot)
3666 
    self._iprot.readMessageEnd()
3667 
    if result.success is not None:
3668 
      return result.success
3669 
    if result.ex is not None:
3670 
      raise result.ex
3671 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3672 
 
3673 
  def shiftToWarehouse(self, orderId, warehouseId):
3674 
    """
3675 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3676 
 
3677 
    Parameters:
3678 
     - orderId
3679 
     - warehouseId
3680 
    """
3681 
    self.send_shiftToWarehouse(orderId, warehouseId)
3682 
    return self.recv_shiftToWarehouse()
3683 
 
3684 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3685 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3686 
    args = shiftToWarehouse_args()
3687 
    args.orderId = orderId
3688 
    args.warehouseId = warehouseId
3689 
    args.write(self._oprot)
3690 
    self._oprot.writeMessageEnd()
3691 
    self._oprot.trans.flush()
3692 
 
3693 
  def recv_shiftToWarehouse(self, ):
3694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3695 
    if mtype == TMessageType.EXCEPTION:
3696 
      x = TApplicationException()
3697 
      x.read(self._iprot)
3698 
      self._iprot.readMessageEnd()
3699 
      raise x
3700 
    result = shiftToWarehouse_result()
3701 
    result.read(self._iprot)
3702 
    self._iprot.readMessageEnd()
3703 
    if result.success is not None:
3704 
      return result.success
3705 
    if result.ex is not None:
3706 
      raise result.ex
3707 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3708 
 
4647 rajveer 3709 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3710 
    """
3711 
    Adds the given delay reason to the given order.
3986 chandransh 3712 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3713 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3714 
 
3553 chandransh 3715 
    Parameters:
3716 
     - orderId
3717 
     - delayReason
3986 chandransh 3718 
     - furtherDelay
4647 rajveer 3719 
     - delayReasonText
3553 chandransh 3720 
    """
4647 rajveer 3721 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3722 
    return self.recv_addDelayReason()
3723 
 
4647 rajveer 3724 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3725 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3726 
    args = addDelayReason_args()
3727 
    args.orderId = orderId
3728 
    args.delayReason = delayReason
3986 chandransh 3729 
    args.furtherDelay = furtherDelay
4647 rajveer 3730 
    args.delayReasonText = delayReasonText
3553 chandransh 3731 
    args.write(self._oprot)
3732 
    self._oprot.writeMessageEnd()
3733 
    self._oprot.trans.flush()
3734 
 
3735 
  def recv_addDelayReason(self, ):
3736 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3737 
    if mtype == TMessageType.EXCEPTION:
3738 
      x = TApplicationException()
3739 
      x.read(self._iprot)
3740 
      self._iprot.readMessageEnd()
3741 
      raise x
3742 
    result = addDelayReason_result()
3743 
    result.read(self._iprot)
3744 
    self._iprot.readMessageEnd()
3745 
    if result.success is not None:
3746 
      return result.success
3747 
    if result.ex is not None:
3748 
      raise result.ex
3749 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3750 
 
3956 chandransh 3751 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3752 
    """
3753 
    Marks the COD orders with given AWB nos. as having been processed.
3754 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3755 
 
3956 chandransh 3756 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3757 
    1. There is no order corresponding to an AWB number.
3758 
    2. The captured amount for a payment exceeds the total payment.
3759 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3760 
 
3761 
    Parameters:
3762 
     - collectedAmountMap
3763 
     - xferBy
3764 
     - xferTxnId
3765 
     - xferDate
3766 
    """
3767 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3768 
    return self.recv_reconcileCodCollection()
3769 
 
3770 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3771 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3772 
    args = reconcileCodCollection_args()
3773 
    args.collectedAmountMap = collectedAmountMap
3774 
    args.xferBy = xferBy
3775 
    args.xferTxnId = xferTxnId
3776 
    args.xferDate = xferDate
3777 
    args.write(self._oprot)
3778 
    self._oprot.writeMessageEnd()
3779 
    self._oprot.trans.flush()
3780 
 
3781 
  def recv_reconcileCodCollection(self, ):
3782 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3783 
    if mtype == TMessageType.EXCEPTION:
3784 
      x = TApplicationException()
3785 
      x.read(self._iprot)
3786 
      self._iprot.readMessageEnd()
3787 
      raise x
3788 
    result = reconcileCodCollection_result()
3789 
    result.read(self._iprot)
3790 
    self._iprot.readMessageEnd()
3791 
    if result.success is not None:
3792 
      return result.success
3793 
    if result.ex is not None:
3794 
      raise result.ex
3795 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3796 
 
4008 mandeep.dh 3797 
  def getTransactionsRequiringExtraProcessing(self, category):
3798 
    """
4065 mandeep.dh 3799 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3800 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3801 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3802 
 
4008 mandeep.dh 3803 
    Parameters:
3804 
     - category
3805 
    """
3806 
    self.send_getTransactionsRequiringExtraProcessing(category)
3807 
    return self.recv_getTransactionsRequiringExtraProcessing()
3808 
 
3809 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3810 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3811 
    args = getTransactionsRequiringExtraProcessing_args()
3812 
    args.category = category
3813 
    args.write(self._oprot)
3814 
    self._oprot.writeMessageEnd()
3815 
    self._oprot.trans.flush()
3816 
 
3817 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3818 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3819 
    if mtype == TMessageType.EXCEPTION:
3820 
      x = TApplicationException()
3821 
      x.read(self._iprot)
3822 
      self._iprot.readMessageEnd()
3823 
      raise x
3824 
    result = getTransactionsRequiringExtraProcessing_result()
3825 
    result.read(self._iprot)
3826 
    self._iprot.readMessageEnd()
3827 
    if result.success is not None:
3828 
      return result.success
3829 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3830 
 
3831 
  def markTransactionAsProcessed(self, transactionId, category):
3832 
    """
3833 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3834 
    It essentially deletes the transaction id record for a particular
3835 
    processing type category (if present) from DB.
3836 
    This is currently used by CRM application.
4008 mandeep.dh 3837 
 
3838 
    Parameters:
3839 
     - transactionId
3840 
     - category
3841 
    """
3842 
    self.send_markTransactionAsProcessed(transactionId, category)
3843 
    self.recv_markTransactionAsProcessed()
3844 
 
3845 
  def send_markTransactionAsProcessed(self, transactionId, category):
3846 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3847 
    args = markTransactionAsProcessed_args()
3848 
    args.transactionId = transactionId
3849 
    args.category = category
3850 
    args.write(self._oprot)
3851 
    self._oprot.writeMessageEnd()
3852 
    self._oprot.trans.flush()
3853 
 
3854 
  def recv_markTransactionAsProcessed(self, ):
3855 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3856 
    if mtype == TMessageType.EXCEPTION:
3857 
      x = TApplicationException()
3858 
      x.read(self._iprot)
3859 
      self._iprot.readMessageEnd()
3860 
      raise x
3861 
    result = markTransactionAsProcessed_result()
3862 
    result.read(self._iprot)
3863 
    self._iprot.readMessageEnd()
3864 
    return
3865 
 
4018 chandransh 3866 
  def getItemWiseRiskyOrdersCount(self, ):
3867 
    """
3868 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3869 
    is defined as one whose shipping date is about to expire.
3870 
    """
3871 
    self.send_getItemWiseRiskyOrdersCount()
3872 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3873 
 
4018 chandransh 3874 
  def send_getItemWiseRiskyOrdersCount(self, ):
3875 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3876 
    args = getItemWiseRiskyOrdersCount_args()
3877 
    args.write(self._oprot)
3878 
    self._oprot.writeMessageEnd()
3879 
    self._oprot.trans.flush()
3880 
 
3881 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3882 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3883 
    if mtype == TMessageType.EXCEPTION:
3884 
      x = TApplicationException()
3885 
      x.read(self._iprot)
3886 
      self._iprot.readMessageEnd()
3887 
      raise x
3888 
    result = getItemWiseRiskyOrdersCount_result()
3889 
    result.read(self._iprot)
3890 
    self._iprot.readMessageEnd()
3891 
    if result.success is not None:
3892 
      return result.success
3893 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3894 
 
4295 varun.gupt 3895 
  def getOrdersForItemIds(self, itemIds):
3896 
    """
3897 
    Returns a list of all orders which have items with given id
3898 
 
3899 
    Parameters:
3900 
     - itemIds
3901 
    """
3902 
    self.send_getOrdersForItemIds(itemIds)
3903 
    return self.recv_getOrdersForItemIds()
3904 
 
3905 
  def send_getOrdersForItemIds(self, itemIds):
3906 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3907 
    args = getOrdersForItemIds_args()
3908 
    args.itemIds = itemIds
3909 
    args.write(self._oprot)
3910 
    self._oprot.writeMessageEnd()
3911 
    self._oprot.trans.flush()
3912 
 
3913 
  def recv_getOrdersForItemIds(self, ):
3914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3915 
    if mtype == TMessageType.EXCEPTION:
3916 
      x = TApplicationException()
3917 
      x.read(self._iprot)
3918 
      self._iprot.readMessageEnd()
3919 
      raise x
3920 
    result = getOrdersForItemIds_result()
3921 
    result.read(self._iprot)
3922 
    self._iprot.readMessageEnd()
3923 
    if result.success is not None:
3924 
      return result.success
3925 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3926 
 
4247 rajveer 3927 
  def markOrderCancellationRequestReceived(self, orderId):
3928 
    """
3929 
    Mark order as cancellation request received. If customer sends request of cancellation of
3930 
    a particular order, this method will be called. It will just change status of the order
3931 
    depending on its current status. It also records the previous status, so that we can move
3932 
    back to that status if cancellation request is denied.
4018 chandransh 3933 
 
4247 rajveer 3934 
    Parameters:
3935 
     - orderId
3936 
    """
3937 
    self.send_markOrderCancellationRequestReceived(orderId)
3938 
    self.recv_markOrderCancellationRequestReceived()
3939 
 
3940 
  def send_markOrderCancellationRequestReceived(self, orderId):
3941 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3942 
    args = markOrderCancellationRequestReceived_args()
3943 
    args.orderId = orderId
3944 
    args.write(self._oprot)
3945 
    self._oprot.writeMessageEnd()
3946 
    self._oprot.trans.flush()
3947 
 
3948 
  def recv_markOrderCancellationRequestReceived(self, ):
3949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3950 
    if mtype == TMessageType.EXCEPTION:
3951 
      x = TApplicationException()
3952 
      x.read(self._iprot)
3953 
      self._iprot.readMessageEnd()
3954 
      raise x
3955 
    result = markOrderCancellationRequestReceived_result()
3956 
    result.read(self._iprot)
3957 
    self._iprot.readMessageEnd()
3958 
    if result.ex is not None:
3959 
      raise result.ex
3960 
    return
3961 
 
3962 
  def markOrderCancellationRequestConfirmed(self, orderId):
3963 
    """
3964 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3965 
    cancellation request confirmed. After this OM will be able to cancel the order.
3966 
 
3967 
    Parameters:
3968 
     - orderId
3969 
    """
3970 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3971 
    self.recv_markOrderCancellationRequestConfirmed()
3972 
 
3973 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3974 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3975 
    args = markOrderCancellationRequestConfirmed_args()
3976 
    args.orderId = orderId
3977 
    args.write(self._oprot)
3978 
    self._oprot.writeMessageEnd()
3979 
    self._oprot.trans.flush()
3980 
 
3981 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3982 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3983 
    if mtype == TMessageType.EXCEPTION:
3984 
      x = TApplicationException()
3985 
      x.read(self._iprot)
3986 
      self._iprot.readMessageEnd()
3987 
      raise x
3988 
    result = markOrderCancellationRequestConfirmed_result()
3989 
    result.read(self._iprot)
3990 
    self._iprot.readMessageEnd()
3991 
    if result.ex is not None:
3992 
      raise result.ex
3993 
    return
3994 
 
3995 
  def markOrderCancellationRequestDenied(self, orderId):
3996 
    """
3997 
    If we decide to not to cancel order, we will move the order ro previous status.
3998 
 
3999 
    Parameters:
4000 
     - orderId
4001 
    """
4002 
    self.send_markOrderCancellationRequestDenied(orderId)
4003 
    self.recv_markOrderCancellationRequestDenied()
4004 
 
4005 
  def send_markOrderCancellationRequestDenied(self, orderId):
4006 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4007 
    args = markOrderCancellationRequestDenied_args()
4008 
    args.orderId = orderId
4009 
    args.write(self._oprot)
4010 
    self._oprot.writeMessageEnd()
4011 
    self._oprot.trans.flush()
4012 
 
4013 
  def recv_markOrderCancellationRequestDenied(self, ):
4014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4015 
    if mtype == TMessageType.EXCEPTION:
4016 
      x = TApplicationException()
4017 
      x.read(self._iprot)
4018 
      self._iprot.readMessageEnd()
4019 
      raise x
4020 
    result = markOrderCancellationRequestDenied_result()
4021 
    result.read(self._iprot)
4022 
    self._iprot.readMessageEnd()
4023 
    if result.ex is not None:
4024 
      raise result.ex
4025 
    return
4026 
 
4258 rajveer 4027 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4028 
    """
4258 rajveer 4029 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4030 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4031 
 
4032 
    Parameters:
4258 rajveer 4033 
     - transactionId
4247 rajveer 4034 
    """
4258 rajveer 4035 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4036 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4037 
 
4258 rajveer 4038 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4039 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4040 
    args = markTransactionAsPaymentFlagRemoved_args()
4041 
    args.transactionId = transactionId
4247 rajveer 4042 
    args.write(self._oprot)
4043 
    self._oprot.writeMessageEnd()
4044 
    self._oprot.trans.flush()
4045 
 
4258 rajveer 4046 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4048 
    if mtype == TMessageType.EXCEPTION:
4049 
      x = TApplicationException()
4050 
      x.read(self._iprot)
4051 
      self._iprot.readMessageEnd()
4052 
      raise x
4258 rajveer 4053 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4054 
    result.read(self._iprot)
4055 
    self._iprot.readMessageEnd()
4056 
    if result.ex is not None:
4057 
      raise result.ex
4058 
    return
4059 
 
4259 anupam.sin 4060 
  def refundTransaction(self, transactionId, refundedBy, reason):
4061 
    """
4062 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4063 
    need to be cancelled
4247 rajveer 4064 
 
4259 anupam.sin 4065 
    Parameters:
4066 
     - transactionId
4067 
     - refundedBy
4068 
     - reason
4069 
    """
4070 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4071 
    self.recv_refundTransaction()
4072 
 
4073 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4074 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4075 
    args = refundTransaction_args()
4076 
    args.transactionId = transactionId
4077 
    args.refundedBy = refundedBy
4078 
    args.reason = reason
4079 
    args.write(self._oprot)
4080 
    self._oprot.writeMessageEnd()
4081 
    self._oprot.trans.flush()
4082 
 
4083 
  def recv_refundTransaction(self, ):
4084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4085 
    if mtype == TMessageType.EXCEPTION:
4086 
      x = TApplicationException()
4087 
      x.read(self._iprot)
4088 
      self._iprot.readMessageEnd()
4089 
      raise x
4090 
    result = refundTransaction_result()
4091 
    result.read(self._iprot)
4092 
    self._iprot.readMessageEnd()
4093 
    if result.ex is not None:
4094 
      raise result.ex
4095 
    return
4096 
 
4324 mandeep.dh 4097 
  def updateShipmentAddress(self, orderId, addressId):
4098 
    """
4099 
    Updates shipment address of an order. Delivery and shipping date estimates
4100 
    etc. are also updated here.
4101 
 
4102 
    Throws TransactionServiceException in case address change is not
4103 
    possible due to certain reasons such as new pincode in address is
4104 
    not serviceable etc.
4105 
 
4106 
    Parameters:
4107 
     - orderId
4108 
     - addressId
4109 
    """
4110 
    self.send_updateShipmentAddress(orderId, addressId)
4111 
    self.recv_updateShipmentAddress()
4112 
 
4113 
  def send_updateShipmentAddress(self, orderId, addressId):
4114 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4115 
    args = updateShipmentAddress_args()
4116 
    args.orderId = orderId
4117 
    args.addressId = addressId
4118 
    args.write(self._oprot)
4119 
    self._oprot.writeMessageEnd()
4120 
    self._oprot.trans.flush()
4121 
 
4122 
  def recv_updateShipmentAddress(self, ):
4123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4124 
    if mtype == TMessageType.EXCEPTION:
4125 
      x = TApplicationException()
4126 
      x.read(self._iprot)
4127 
      self._iprot.readMessageEnd()
4128 
      raise x
4129 
    result = updateShipmentAddress_result()
4130 
    result.read(self._iprot)
4131 
    self._iprot.readMessageEnd()
4132 
    if result.ex is not None:
4133 
      raise result.ex
4134 
    return
4135 
 
4285 rajveer 4136 
  def acceptOrdersForItemId(self, itemId, inventory):
4137 
    """
4138 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4139 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4140 
 
4285 rajveer 4141 
    Parameters:
4142 
     - itemId
4143 
     - inventory
4144 
    """
4145 
    self.send_acceptOrdersForItemId(itemId, inventory)
4146 
    return self.recv_acceptOrdersForItemId()
4147 
 
4148 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4149 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4150 
    args = acceptOrdersForItemId_args()
4151 
    args.itemId = itemId
4152 
    args.inventory = inventory
4153 
    args.write(self._oprot)
4154 
    self._oprot.writeMessageEnd()
4155 
    self._oprot.trans.flush()
4156 
 
4157 
  def recv_acceptOrdersForItemId(self, ):
4158 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4159 
    if mtype == TMessageType.EXCEPTION:
4160 
      x = TApplicationException()
4161 
      x.read(self._iprot)
4162 
      self._iprot.readMessageEnd()
4163 
      raise x
4164 
    result = acceptOrdersForItemId_result()
4165 
    result.read(self._iprot)
4166 
    self._iprot.readMessageEnd()
4167 
    if result.success is not None:
4168 
      return result.success
4169 
    if result.ex is not None:
4170 
      raise result.ex
4171 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4172 
 
4369 rajveer 4173 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4174 
    """
4175 
    Parameters:
4176 
     - vendorId
4177 
     - itemId
4178 
     - quantity
4179 
     - estimate
4369 rajveer 4180 
     - isReminder
4303 rajveer 4181 
    """
4369 rajveer 4182 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4183 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4184 
 
4369 rajveer 4185 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4186 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4187 
    args = markOrdersAsPORaised_args()
4188 
    args.vendorId = vendorId
4189 
    args.itemId = itemId
4190 
    args.quantity = quantity
4191 
    args.estimate = estimate
4369 rajveer 4192 
    args.isReminder = isReminder
4303 rajveer 4193 
    args.write(self._oprot)
4194 
    self._oprot.writeMessageEnd()
4195 
    self._oprot.trans.flush()
4196 
 
4197 
  def recv_markOrdersAsPORaised(self, ):
4198 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4199 
    if mtype == TMessageType.EXCEPTION:
4200 
      x = TApplicationException()
4201 
      x.read(self._iprot)
4202 
      self._iprot.readMessageEnd()
4203 
      raise x
4204 
    result = markOrdersAsPORaised_result()
4205 
    result.read(self._iprot)
4206 
    self._iprot.readMessageEnd()
4207 
    if result.ex is not None:
4208 
      raise result.ex
4209 
    return
4210 
 
4369 rajveer 4211 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4212 
    """
4213 
    Parameters:
4214 
     - vendorId
4215 
     - itemId
4216 
     - quantity
4217 
     - estimate
4369 rajveer 4218 
     - isReminder
4303 rajveer 4219 
    """
4369 rajveer 4220 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4221 
    self.recv_markOrdersAsReversalInitiated()
4222 
 
4369 rajveer 4223 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4224 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4225 
    args = markOrdersAsReversalInitiated_args()
4226 
    args.vendorId = vendorId
4227 
    args.itemId = itemId
4228 
    args.quantity = quantity
4229 
    args.estimate = estimate
4369 rajveer 4230 
    args.isReminder = isReminder
4303 rajveer 4231 
    args.write(self._oprot)
4232 
    self._oprot.writeMessageEnd()
4233 
    self._oprot.trans.flush()
4234 
 
4235 
  def recv_markOrdersAsReversalInitiated(self, ):
4236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4237 
    if mtype == TMessageType.EXCEPTION:
4238 
      x = TApplicationException()
4239 
      x.read(self._iprot)
4240 
      self._iprot.readMessageEnd()
4241 
      raise x
4242 
    result = markOrdersAsReversalInitiated_result()
4243 
    result.read(self._iprot)
4244 
    self._iprot.readMessageEnd()
4245 
    if result.ex is not None:
4246 
      raise result.ex
4247 
    return
4248 
 
4369 rajveer 4249 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4250 
    """
4251 
    Parameters:
4252 
     - vendorId
4253 
     - itemId
4254 
     - quantity
4255 
     - estimate
4369 rajveer 4256 
     - isReminder
4303 rajveer 4257 
    """
4369 rajveer 4258 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4259 
    self.recv_markOrdersAsNotAvailabke()
4260 
 
4369 rajveer 4261 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4262 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4263 
    args = markOrdersAsNotAvailabke_args()
4264 
    args.vendorId = vendorId
4265 
    args.itemId = itemId
4266 
    args.quantity = quantity
4267 
    args.estimate = estimate
4369 rajveer 4268 
    args.isReminder = isReminder
4303 rajveer 4269 
    args.write(self._oprot)
4270 
    self._oprot.writeMessageEnd()
4271 
    self._oprot.trans.flush()
4272 
 
4273 
  def recv_markOrdersAsNotAvailabke(self, ):
4274 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4275 
    if mtype == TMessageType.EXCEPTION:
4276 
      x = TApplicationException()
4277 
      x.read(self._iprot)
4278 
      self._iprot.readMessageEnd()
4279 
      raise x
4280 
    result = markOrdersAsNotAvailabke_result()
4281 
    result.read(self._iprot)
4282 
    self._iprot.readMessageEnd()
4283 
    if result.ex is not None:
4284 
      raise result.ex
4285 
    return
4286 
 
4369 rajveer 4287 
  def markOrdersAsTimeout(self, vendorId):
4288 
    """
4289 
    Parameters:
4290 
     - vendorId
4291 
    """
4292 
    self.send_markOrdersAsTimeout(vendorId)
4293 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4294 
 
4369 rajveer 4295 
  def send_markOrdersAsTimeout(self, vendorId):
4296 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4297 
    args = markOrdersAsTimeout_args()
4298 
    args.vendorId = vendorId
4299 
    args.write(self._oprot)
4300 
    self._oprot.writeMessageEnd()
4301 
    self._oprot.trans.flush()
4302 
 
4303 
  def recv_markOrdersAsTimeout(self, ):
4304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4305 
    if mtype == TMessageType.EXCEPTION:
4306 
      x = TApplicationException()
4307 
      x.read(self._iprot)
4308 
      self._iprot.readMessageEnd()
4309 
      raise x
4310 
    result = markOrdersAsTimeout_result()
4311 
    result.read(self._iprot)
4312 
    self._iprot.readMessageEnd()
4313 
    if result.success is not None:
4314 
      return result.success
4315 
    if result.ex is not None:
4316 
      raise result.ex
4317 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4318 
 
4662 rajveer 4319 
  def markOrderAsLostInTransit(self, orderId):
4320 
    """
4321 
    Mark order as LOST_IN_TRANSIT
4322 
 
4323 
    Parameters:
4324 
     - orderId
4325 
    """
4326 
    self.send_markOrderAsLostInTransit(orderId)
4327 
    return self.recv_markOrderAsLostInTransit()
4328 
 
4329 
  def send_markOrderAsLostInTransit(self, orderId):
4330 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4331 
    args = markOrderAsLostInTransit_args()
4332 
    args.orderId = orderId
4333 
    args.write(self._oprot)
4334 
    self._oprot.writeMessageEnd()
4335 
    self._oprot.trans.flush()
4336 
 
4337 
  def recv_markOrderAsLostInTransit(self, ):
4338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4339 
    if mtype == TMessageType.EXCEPTION:
4340 
      x = TApplicationException()
4341 
      x.read(self._iprot)
4342 
      self._iprot.readMessageEnd()
4343 
      raise x
4344 
    result = markOrderAsLostInTransit_result()
4345 
    result.read(self._iprot)
4346 
    self._iprot.readMessageEnd()
4347 
    if result.success is not None:
4348 
      return result.success
4349 
    if result.ex is not None:
4350 
      raise result.ex
4351 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4352 
 
4386 anupam.sin 4353 
  def getOrderForAwb(self, awb):
4354 
    """
4355 
    Returns the order corresponding to an AWB number
4369 rajveer 4356 
 
4386 anupam.sin 4357 
    Parameters:
4358 
     - awb
4359 
    """
4360 
    self.send_getOrderForAwb(awb)
4361 
    return self.recv_getOrderForAwb()
4362 
 
4363 
  def send_getOrderForAwb(self, awb):
4364 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4365 
    args = getOrderForAwb_args()
4366 
    args.awb = awb
4367 
    args.write(self._oprot)
4368 
    self._oprot.writeMessageEnd()
4369 
    self._oprot.trans.flush()
4370 
 
4371 
  def recv_getOrderForAwb(self, ):
4372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4373 
    if mtype == TMessageType.EXCEPTION:
4374 
      x = TApplicationException()
4375 
      x.read(self._iprot)
4376 
      self._iprot.readMessageEnd()
4377 
      raise x
4378 
    result = getOrderForAwb_result()
4379 
    result.read(self._iprot)
4380 
    self._iprot.readMessageEnd()
4381 
    if result.success is not None:
4382 
      return result.success
4383 
    if result.ex is not None:
4384 
      raise result.ex
4385 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4386 
 
4910 phani.kuma 4387 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4388 
    """
4910 phani.kuma 4389 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4390 
 
4506 phani.kuma 4391 
    Parameters:
4392 
     - logistics_provider_id
4910 phani.kuma 4393 
     - order_status_list
4506 phani.kuma 4394 
    """
4910 phani.kuma 4395 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4396 
    return self.recv_getOrdersForProviderForStatus()
4397 
 
4910 phani.kuma 4398 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4399 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4400 
    args = getOrdersForProviderForStatus_args()
4401 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4402 
    args.order_status_list = order_status_list
4506 phani.kuma 4403 
    args.write(self._oprot)
4404 
    self._oprot.writeMessageEnd()
4405 
    self._oprot.trans.flush()
4406 
 
4407 
  def recv_getOrdersForProviderForStatus(self, ):
4408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4409 
    if mtype == TMessageType.EXCEPTION:
4410 
      x = TApplicationException()
4411 
      x.read(self._iprot)
4412 
      self._iprot.readMessageEnd()
4413 
      raise x
4414 
    result = getOrdersForProviderForStatus_result()
4415 
    result.read(self._iprot)
4416 
    self._iprot.readMessageEnd()
4417 
    if result.success is not None:
4418 
      return result.success
4419 
    if result.ex is not None:
4420 
      raise result.ex
4421 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4422 
 
4600 varun.gupt 4423 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4424 
    """
4425 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4426 
 
4600 varun.gupt 4427 
    Parameters:
4428 
     - vendorId
4429 
     - billingDateFrom
4430 
     - billingDateTo
4431 
    """
4432 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4433 
    return self.recv_getBilledOrdersForVendor()
4434 
 
4435 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4436 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4437 
    args = getBilledOrdersForVendor_args()
4438 
    args.vendorId = vendorId
4439 
    args.billingDateFrom = billingDateFrom
4440 
    args.billingDateTo = billingDateTo
4441 
    args.write(self._oprot)
4442 
    self._oprot.writeMessageEnd()
4443 
    self._oprot.trans.flush()
4444 
 
4445 
  def recv_getBilledOrdersForVendor(self, ):
4446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4447 
    if mtype == TMessageType.EXCEPTION:
4448 
      x = TApplicationException()
4449 
      x.read(self._iprot)
4450 
      self._iprot.readMessageEnd()
4451 
      raise x
4452 
    result = getBilledOrdersForVendor_result()
4453 
    result.read(self._iprot)
4454 
    self._iprot.readMessageEnd()
4455 
    if result.success is not None:
4456 
      return result.success
4457 
    if result.ex is not None:
4458 
      raise result.ex
4459 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4460 
 
4607 rajveer 4461 
  def getSlippedSippingDateOrders(self, ):
4462 
    self.send_getSlippedSippingDateOrders()
4463 
    return self.recv_getSlippedSippingDateOrders()
4464 
 
4465 
  def send_getSlippedSippingDateOrders(self, ):
4466 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4467 
    args = getSlippedSippingDateOrders_args()
4468 
    args.write(self._oprot)
4469 
    self._oprot.writeMessageEnd()
4470 
    self._oprot.trans.flush()
4471 
 
4472 
  def recv_getSlippedSippingDateOrders(self, ):
4473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4474 
    if mtype == TMessageType.EXCEPTION:
4475 
      x = TApplicationException()
4476 
      x.read(self._iprot)
4477 
      self._iprot.readMessageEnd()
4478 
      raise x
4479 
    result = getSlippedSippingDateOrders_result()
4480 
    result.read(self._iprot)
4481 
    self._iprot.readMessageEnd()
4482 
    if result.success is not None:
4483 
      return result.success
4484 
    if result.ex is not None:
4485 
      raise result.ex
4486 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4487 
 
4709 rajveer 4488 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4489 
    """
4490 
    Parameters:
4491 
     - cancelDateFrom
4492 
     - cancelDateTo
4493 
    """
4494 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4495 
    return self.recv_getCancelledOrders()
4496 
 
4497 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4498 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4499 
    args = getCancelledOrders_args()
4500 
    args.cancelDateFrom = cancelDateFrom
4501 
    args.cancelDateTo = cancelDateTo
4502 
    args.write(self._oprot)
4503 
    self._oprot.writeMessageEnd()
4504 
    self._oprot.trans.flush()
4505 
 
4506 
  def recv_getCancelledOrders(self, ):
4507 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4508 
    if mtype == TMessageType.EXCEPTION:
4509 
      x = TApplicationException()
4510 
      x.read(self._iprot)
4511 
      self._iprot.readMessageEnd()
4512 
      raise x
4513 
    result = getCancelledOrders_result()
4514 
    result.read(self._iprot)
4515 
    self._iprot.readMessageEnd()
4516 
    if result.success is not None:
4517 
      return result.success
4518 
    if result.ex is not None:
4519 
      raise result.ex
4520 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4521 
 
4600 varun.gupt 4522 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4523 
    """
4524 
    Parameters:
4525 
     - mapAWBAndAmount
4526 
    """
4527 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4528 
    self.recv_saveBluedartSettlements()
4529 
 
4530 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4531 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4532 
    args = saveBluedartSettlements_args()
4533 
    args.mapAWBAndAmount = mapAWBAndAmount
4534 
    args.write(self._oprot)
4535 
    self._oprot.writeMessageEnd()
4536 
    self._oprot.trans.flush()
4537 
 
4538 
  def recv_saveBluedartSettlements(self, ):
4539 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4540 
    if mtype == TMessageType.EXCEPTION:
4541 
      x = TApplicationException()
4542 
      x.read(self._iprot)
4543 
      self._iprot.readMessageEnd()
4544 
      raise x
4545 
    result = saveBluedartSettlements_result()
4546 
    result.read(self._iprot)
4547 
    self._iprot.readMessageEnd()
4548 
    if result.ex is not None:
4549 
      raise result.ex
4550 
    return
4551 
 
4905 varun.gupt 4552 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4553 
    """
4554 
    Parameters:
4555 
     - settlementDate
4556 
     - paymentGatewayId
4905 varun.gupt 4557 
     - referenceId
4600 varun.gupt 4558 
     - serviceTax
4559 
     - otherCharges
4560 
     - netCollection
4561 
    """
4905 varun.gupt 4562 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4563 
    self.recv_savePaymentSettlements()
4564 
 
4905 varun.gupt 4565 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4566 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4567 
    args = savePaymentSettlements_args()
4568 
    args.settlementDate = settlementDate
4569 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4570 
    args.referenceId = referenceId
4600 varun.gupt 4571 
    args.serviceTax = serviceTax
4572 
    args.otherCharges = otherCharges
4573 
    args.netCollection = netCollection
4574 
    args.write(self._oprot)
4575 
    self._oprot.writeMessageEnd()
4576 
    self._oprot.trans.flush()
4577 
 
4578 
  def recv_savePaymentSettlements(self, ):
4579 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4580 
    if mtype == TMessageType.EXCEPTION:
4581 
      x = TApplicationException()
4582 
      x.read(self._iprot)
4583 
      self._iprot.readMessageEnd()
4584 
      raise x
4585 
    result = savePaymentSettlements_result()
4586 
    result.read(self._iprot)
4587 
    self._iprot.readMessageEnd()
4588 
    if result.ex is not None:
4589 
      raise result.ex
4590 
    return
4591 
 
4592 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4593 
    """
4594 
    Parameters:
4595 
     - settlementId
4596 
     - settlementDate
4597 
     - transactionDateFrom
4598 
     - transactionDateTo
4599 
     - amount
4600 
    """
4601 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4602 
    self.recv_saveEBSSettlementSummary()
4603 
 
4604 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4605 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4606 
    args = saveEBSSettlementSummary_args()
4607 
    args.settlementId = settlementId
4608 
    args.settlementDate = settlementDate
4609 
    args.transactionDateFrom = transactionDateFrom
4610 
    args.transactionDateTo = transactionDateTo
4611 
    args.amount = amount
4612 
    args.write(self._oprot)
4613 
    self._oprot.writeMessageEnd()
4614 
    self._oprot.trans.flush()
4615 
 
4616 
  def recv_saveEBSSettlementSummary(self, ):
4617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4618 
    if mtype == TMessageType.EXCEPTION:
4619 
      x = TApplicationException()
4620 
      x.read(self._iprot)
4621 
      self._iprot.readMessageEnd()
4622 
      raise x
4623 
    result = saveEBSSettlementSummary_result()
4624 
    result.read(self._iprot)
4625 
    self._iprot.readMessageEnd()
4626 
    if result.ex is not None:
4627 
      raise result.ex
4628 
    return
4629 
 
5382 varun.gupt 4630 
  def getSettlementForReferenceId(self, referenceId, paymentGatewayId, isRefund):
4600 varun.gupt 4631 
    """
4632 
    Parameters:
5189 varun.gupt 4633 
     - referenceId
5382 varun.gupt 4634 
     - paymentGatewayId
5189 varun.gupt 4635 
     - isRefund
4600 varun.gupt 4636 
    """
5382 varun.gupt 4637 
    self.send_getSettlementForReferenceId(referenceId, paymentGatewayId, isRefund)
5189 varun.gupt 4638 
    return self.recv_getSettlementForReferenceId()
4600 varun.gupt 4639 
 
5382 varun.gupt 4640 
  def send_getSettlementForReferenceId(self, referenceId, paymentGatewayId, isRefund):
5189 varun.gupt 4641 
    self._oprot.writeMessageBegin('getSettlementForReferenceId', TMessageType.CALL, self._seqid)
4642 
    args = getSettlementForReferenceId_args()
4643 
    args.referenceId = referenceId
5382 varun.gupt 4644 
    args.paymentGatewayId = paymentGatewayId
5189 varun.gupt 4645 
    args.isRefund = isRefund
4600 varun.gupt 4646 
    args.write(self._oprot)
4647 
    self._oprot.writeMessageEnd()
4648 
    self._oprot.trans.flush()
4649 
 
5189 varun.gupt 4650 
  def recv_getSettlementForReferenceId(self, ):
4600 varun.gupt 4651 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4652 
    if mtype == TMessageType.EXCEPTION:
4653 
      x = TApplicationException()
4654 
      x.read(self._iprot)
4655 
      self._iprot.readMessageEnd()
4656 
      raise x
5189 varun.gupt 4657 
    result = getSettlementForReferenceId_result()
4600 varun.gupt 4658 
    result.read(self._iprot)
4659 
    self._iprot.readMessageEnd()
4660 
    if result.success is not None:
4661 
      return result.success
4662 
    if result.ex is not None:
4663 
      raise result.ex
5189 varun.gupt 4664 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForReferenceId failed: unknown result");
4600 varun.gupt 4665 
 
4666 
  def getEBSSettlementSummaries(self, ):
4667 
    self.send_getEBSSettlementSummaries()
4668 
    return self.recv_getEBSSettlementSummaries()
4669 
 
4670 
  def send_getEBSSettlementSummaries(self, ):
4671 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4672 
    args = getEBSSettlementSummaries_args()
4673 
    args.write(self._oprot)
4674 
    self._oprot.writeMessageEnd()
4675 
    self._oprot.trans.flush()
4676 
 
4677 
  def recv_getEBSSettlementSummaries(self, ):
4678 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4679 
    if mtype == TMessageType.EXCEPTION:
4680 
      x = TApplicationException()
4681 
      x.read(self._iprot)
4682 
      self._iprot.readMessageEnd()
4683 
      raise x
4684 
    result = getEBSSettlementSummaries_result()
4685 
    result.read(self._iprot)
4686 
    self._iprot.readMessageEnd()
4687 
    if result.success is not None:
4688 
      return result.success
4689 
    if result.ex is not None:
4690 
      raise result.ex
4691 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4692 
 
4693 
  def markEBSSettlementUploaded(self, settlementId):
4694 
    """
4695 
    Parameters:
4696 
     - settlementId
4697 
    """
4698 
    self.send_markEBSSettlementUploaded(settlementId)
4699 
    self.recv_markEBSSettlementUploaded()
4700 
 
4701 
  def send_markEBSSettlementUploaded(self, settlementId):
4702 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4703 
    args = markEBSSettlementUploaded_args()
4704 
    args.settlementId = settlementId
4705 
    args.write(self._oprot)
4706 
    self._oprot.writeMessageEnd()
4707 
    self._oprot.trans.flush()
4708 
 
4709 
  def recv_markEBSSettlementUploaded(self, ):
4710 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4711 
    if mtype == TMessageType.EXCEPTION:
4712 
      x = TApplicationException()
4713 
      x.read(self._iprot)
4714 
      self._iprot.readMessageEnd()
4715 
      raise x
4716 
    result = markEBSSettlementUploaded_result()
4717 
    result.read(self._iprot)
4718 
    self._iprot.readMessageEnd()
4719 
    if result.ex is not None:
4720 
      raise result.ex
4721 
    return
4722 
 
4723 
  def getEBSSettlementDate(self, settlementId):
4724 
    """
4725 
    Parameters:
4726 
     - settlementId
4727 
    """
4728 
    self.send_getEBSSettlementDate(settlementId)
4729 
    return self.recv_getEBSSettlementDate()
4730 
 
4731 
  def send_getEBSSettlementDate(self, settlementId):
4732 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4733 
    args = getEBSSettlementDate_args()
4734 
    args.settlementId = settlementId
4735 
    args.write(self._oprot)
4736 
    self._oprot.writeMessageEnd()
4737 
    self._oprot.trans.flush()
4738 
 
4739 
  def recv_getEBSSettlementDate(self, ):
4740 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4741 
    if mtype == TMessageType.EXCEPTION:
4742 
      x = TApplicationException()
4743 
      x.read(self._iprot)
4744 
      self._iprot.readMessageEnd()
4745 
      raise x
4746 
    result = getEBSSettlementDate_result()
4747 
    result.read(self._iprot)
4748 
    self._iprot.readMessageEnd()
4749 
    if result.success is not None:
4750 
      return result.success
4751 
    if result.ex is not None:
4752 
      raise result.ex
4753 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4754 
 
4715 varun.gupt 4755 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4756 
    """
4757 
    Parameters:
4758 
     - settlementDateFrom
4759 
     - settlementDateTo
4760 
     - isRefund
4761 
    """
4762 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4763 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4764 
 
4715 varun.gupt 4765 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4766 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4767 
    args = getSettlementsByDate_args()
4768 
    args.settlementDateFrom = settlementDateFrom
4769 
    args.settlementDateTo = settlementDateTo
4770 
    args.isRefund = isRefund
4771 
    args.write(self._oprot)
4772 
    self._oprot.writeMessageEnd()
4773 
    self._oprot.trans.flush()
4774 
 
4775 
  def recv_getSettlementsByDate(self, ):
4776 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4777 
    if mtype == TMessageType.EXCEPTION:
4778 
      x = TApplicationException()
4779 
      x.read(self._iprot)
4780 
      self._iprot.readMessageEnd()
4781 
      raise x
4782 
    result = getSettlementsByDate_result()
4783 
    result.read(self._iprot)
4784 
    self._iprot.readMessageEnd()
4785 
    if result.success is not None:
4786 
      return result.success
4787 
    if result.ex is not None:
4788 
      raise result.ex
4789 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4790 
 
4791 
  def getReshippedOrderIds(self, orderIds):
4792 
    """
4793 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4794 
 
4795 
    Parameters:
4796 
     - orderIds
4797 
    """
4798 
    self.send_getReshippedOrderIds(orderIds)
4799 
    return self.recv_getReshippedOrderIds()
4800 
 
4801 
  def send_getReshippedOrderIds(self, orderIds):
4802 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4803 
    args = getReshippedOrderIds_args()
4804 
    args.orderIds = orderIds
4805 
    args.write(self._oprot)
4806 
    self._oprot.writeMessageEnd()
4807 
    self._oprot.trans.flush()
4808 
 
4809 
  def recv_getReshippedOrderIds(self, ):
4810 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4811 
    if mtype == TMessageType.EXCEPTION:
4812 
      x = TApplicationException()
4813 
      x.read(self._iprot)
4814 
      self._iprot.readMessageEnd()
4815 
      raise x
4816 
    result = getReshippedOrderIds_result()
4817 
    result.read(self._iprot)
4818 
    self._iprot.readMessageEnd()
4819 
    if result.success is not None:
4820 
      return result.success
4821 
    if result.ex is not None:
4822 
      raise result.ex
4823 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4824 
 
5348 anupam.sin 4825 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4826 
    """
4827 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
4828 
    the quantities for which the PO is raised.
4829 
 
4830 
    Parameters:
4831 
     - itemIdQuantityMap
4832 
     - purchaseOrderId
4833 
     - warehouseId
4834 
    """
4835 
    self.send_updateOrdersAsPORaised(itemIdQuantityMap, purchaseOrderId, warehouseId)
4836 
    self.recv_updateOrdersAsPORaised()
4837 
 
4838 
  def send_updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4839 
    self._oprot.writeMessageBegin('updateOrdersAsPORaised', TMessageType.CALL, self._seqid)
4840 
    args = updateOrdersAsPORaised_args()
4841 
    args.itemIdQuantityMap = itemIdQuantityMap
4842 
    args.purchaseOrderId = purchaseOrderId
4843 
    args.warehouseId = warehouseId
4844 
    args.write(self._oprot)
4845 
    self._oprot.writeMessageEnd()
4846 
    self._oprot.trans.flush()
4847 
 
4848 
  def recv_updateOrdersAsPORaised(self, ):
4849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4850 
    if mtype == TMessageType.EXCEPTION:
4851 
      x = TApplicationException()
4852 
      x.read(self._iprot)
4853 
      self._iprot.readMessageEnd()
4854 
      raise x
4855 
    result = updateOrdersAsPORaised_result()
4856 
    result.read(self._iprot)
4857 
    self._iprot.readMessageEnd()
4858 
    if result.ex is not None:
4859 
      raise result.ex
4860 
    return
4861 
 
4875 varun.gupt 4862 
  def getOrdersWhereVendorNotPaid(self, vendorId):
4863 
    """
4864 
    Parameters:
4865 
     - vendorId
4866 
    """
4867 
    self.send_getOrdersWhereVendorNotPaid(vendorId)
4868 
    return self.recv_getOrdersWhereVendorNotPaid()
4757 mandeep.dh 4869 
 
4875 varun.gupt 4870 
  def send_getOrdersWhereVendorNotPaid(self, vendorId):
4871 
    self._oprot.writeMessageBegin('getOrdersWhereVendorNotPaid', TMessageType.CALL, self._seqid)
4872 
    args = getOrdersWhereVendorNotPaid_args()
4873 
    args.vendorId = vendorId
4874 
    args.write(self._oprot)
4875 
    self._oprot.writeMessageEnd()
4876 
    self._oprot.trans.flush()
4877 
 
4878 
  def recv_getOrdersWhereVendorNotPaid(self, ):
4879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4880 
    if mtype == TMessageType.EXCEPTION:
4881 
      x = TApplicationException()
4882 
      x.read(self._iprot)
4883 
      self._iprot.readMessageEnd()
4884 
      raise x
4885 
    result = getOrdersWhereVendorNotPaid_result()
4886 
    result.read(self._iprot)
4887 
    self._iprot.readMessageEnd()
4888 
    if result.success is not None:
4889 
      return result.success
4890 
    if result.ex is not None:
4891 
      raise result.ex
4892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersWhereVendorNotPaid failed: unknown result");
4893 
 
5031 varun.gupt 4894 
  def getStatusDistributionOfOrders(self, startDate, endDate):
4895 
    """
4896 
    Parameters:
4897 
     - startDate
4898 
     - endDate
4899 
    """
4900 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
4901 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 4902 
 
5031 varun.gupt 4903 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
4904 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
4905 
    args = getStatusDistributionOfOrders_args()
4906 
    args.startDate = startDate
4907 
    args.endDate = endDate
4908 
    args.write(self._oprot)
4909 
    self._oprot.writeMessageEnd()
4910 
    self._oprot.trans.flush()
4911 
 
4912 
  def recv_getStatusDistributionOfOrders(self, ):
4913 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4914 
    if mtype == TMessageType.EXCEPTION:
4915 
      x = TApplicationException()
4916 
      x.read(self._iprot)
4917 
      self._iprot.readMessageEnd()
4918 
      raise x
4919 
    result = getStatusDistributionOfOrders_result()
4920 
    result.read(self._iprot)
4921 
    self._iprot.readMessageEnd()
4922 
    if result.success is not None:
4923 
      return result.success
4924 
    if result.ex is not None:
4925 
      raise result.ex
4926 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
4927 
 
5067 varun.gupt 4928 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
4929 
    """
4930 
    Parameters:
4931 
     - status
4932 
     - startDatetime
4933 
     - endDatetime
4934 
    """
4935 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
4936 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 4937 
 
5067 varun.gupt 4938 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
4939 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
4940 
    args = getOrderIdsForStatus_args()
4941 
    args.status = status
4942 
    args.startDatetime = startDatetime
4943 
    args.endDatetime = endDatetime
4944 
    args.write(self._oprot)
4945 
    self._oprot.writeMessageEnd()
4946 
    self._oprot.trans.flush()
4947 
 
4948 
  def recv_getOrderIdsForStatus(self, ):
4949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4950 
    if mtype == TMessageType.EXCEPTION:
4951 
      x = TApplicationException()
4952 
      x.read(self._iprot)
4953 
      self._iprot.readMessageEnd()
4954 
      raise x
4955 
    result = getOrderIdsForStatus_result()
4956 
    result.read(self._iprot)
4957 
    self._iprot.readMessageEnd()
4958 
    if result.success is not None:
4959 
      return result.success
4960 
    if result.ex is not None:
4961 
      raise result.ex
4962 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
4963 
 
5348 anupam.sin 4964 
  def updateCODAgent(self, agent, orderId):
4965 
    """
4966 
    Updates the agent who handled the COD verification call
4967 
 
4968 
    Parameters:
4969 
     - agent
4970 
     - orderId
4971 
    """
4972 
    self.send_updateCODAgent(agent, orderId)
4973 
    self.recv_updateCODAgent()
4974 
 
4975 
  def send_updateCODAgent(self, agent, orderId):
4976 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
4977 
    args = updateCODAgent_args()
4978 
    args.agent = agent
4979 
    args.orderId = orderId
4980 
    args.write(self._oprot)
4981 
    self._oprot.writeMessageEnd()
4982 
    self._oprot.trans.flush()
4983 
 
4984 
  def recv_updateCODAgent(self, ):
4985 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4986 
    if mtype == TMessageType.EXCEPTION:
4987 
      x = TApplicationException()
4988 
      x.read(self._iprot)
4989 
      self._iprot.readMessageEnd()
4990 
      raise x
4991 
    result = updateCODAgent_result()
4992 
    result.read(self._iprot)
4993 
    self._iprot.readMessageEnd()
4994 
    if result.ex is not None:
4995 
      raise result.ex
4996 
    return
4997 
 
5099 varun.gupt 4998 
  def updateOrderAsPaidToVendor(self, orderId):
4999 
    """
5000 
    Parameters:
5001 
     - orderId
5002 
    """
5003 
    self.send_updateOrderAsPaidToVendor(orderId)
5004 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5005 
 
5099 varun.gupt 5006 
  def send_updateOrderAsPaidToVendor(self, orderId):
5007 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5008 
    args = updateOrderAsPaidToVendor_args()
5009 
    args.orderId = orderId
5010 
    args.write(self._oprot)
5011 
    self._oprot.writeMessageEnd()
5012 
    self._oprot.trans.flush()
5013 
 
5014 
  def recv_updateOrderAsPaidToVendor(self, ):
5015 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5016 
    if mtype == TMessageType.EXCEPTION:
5017 
      x = TApplicationException()
5018 
      x.read(self._iprot)
5019 
      self._iprot.readMessageEnd()
5020 
      raise x
5021 
    result = updateOrderAsPaidToVendor_result()
5022 
    result.read(self._iprot)
5023 
    self._iprot.readMessageEnd()
5024 
    if result.ex is not None:
5025 
      raise result.ex
5026 
    return
5027 
 
5208 varun.gupt 5028 
  def getRefundedOrdersMarkedPaid(self, ):
5029 
    self.send_getRefundedOrdersMarkedPaid()
5030 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5031 
 
5208 varun.gupt 5032 
  def send_getRefundedOrdersMarkedPaid(self, ):
5033 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5034 
    args = getRefundedOrdersMarkedPaid_args()
5035 
    args.write(self._oprot)
5036 
    self._oprot.writeMessageEnd()
5037 
    self._oprot.trans.flush()
5038 
 
5039 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5040 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5041 
    if mtype == TMessageType.EXCEPTION:
5042 
      x = TApplicationException()
5043 
      x.read(self._iprot)
5044 
      self._iprot.readMessageEnd()
5045 
      raise x
5046 
    result = getRefundedOrdersMarkedPaid_result()
5047 
    result.read(self._iprot)
5048 
    self._iprot.readMessageEnd()
5049 
    if result.success is not None:
5050 
      return result.success
5051 
    if result.ex is not None:
5052 
      raise result.ex
5053 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5054 
 
5055 
 
3376 rajveer 5056 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 5057 
  def __init__(self, handler):
3376 rajveer 5058 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 5059 
    self._processMap["createTransaction"] = Processor.process_createTransaction
5060 
    self._processMap["getTransaction"] = Processor.process_getTransaction
5061 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 5062 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 5063 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
5064 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 5065 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 5066 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 5067 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
5068 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 5069 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 5070 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 5071 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
5072 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 5073 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
5074 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
5075 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
5076 
    self._processMap["createOrder"] = Processor.process_createOrder
5077 
    self._processMap["getOrder"] = Processor.process_getOrder
5078 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 5079 
    self._processMap["getOrderList"] = Processor.process_getOrderList
1528 ankur.sing 5080 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 5081 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 5082 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 5083 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 5084 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
5085 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
5086 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
5087 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 5088 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 5089 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 5090 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
5091 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
5092 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 5093 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 5094 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 5095 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 5096 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 5097 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 5098 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
5099 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 5100 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 5101 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
5102 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
5103 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
5104 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
5105 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 5106 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 5107 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 5108 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 5109 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 5110 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
5111 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 5112 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
5113 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 5114 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
5115 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 5116 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 5117 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 5118 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 5119 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 5120 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 5121 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 5122 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 5123 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
5124 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 5125 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 5126 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 5127 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 5128 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 5129 
    self._processMap["changeItem"] = Processor.process_changeItem
5130 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 5131 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 5132 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 5133 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
5134 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 5135 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 5136 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 5137 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
5138 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
5139 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 5140 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 5141 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 5142 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 5143 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 5144 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
5145 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
5146 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 5147 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 5148 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 5149 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 5150 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 5151 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 5152 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 5153 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 5154 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
5155 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
5156 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5189 varun.gupt 5157 
    self._processMap["getSettlementForReferenceId"] = Processor.process_getSettlementForReferenceId
4600 varun.gupt 5158 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
5159 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
5160 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 5161 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
5162 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5348 anupam.sin 5163 
    self._processMap["updateOrdersAsPORaised"] = Processor.process_updateOrdersAsPORaised
4875 varun.gupt 5164 
    self._processMap["getOrdersWhereVendorNotPaid"] = Processor.process_getOrdersWhereVendorNotPaid
5031 varun.gupt 5165 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 5166 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 5167 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 5168 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5208 varun.gupt 5169 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
94 ashish 5170 
 
5171 
  def process(self, iprot, oprot):
5172 
    (name, type, seqid) = iprot.readMessageBegin()
5173 
    if name not in self._processMap:
5174 
      iprot.skip(TType.STRUCT)
5175 
      iprot.readMessageEnd()
5176 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5177 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5178 
      x.write(oprot)
5179 
      oprot.writeMessageEnd()
5180 
      oprot.trans.flush()
5181 
      return
5182 
    else:
5183 
      self._processMap[name](self, seqid, iprot, oprot)
5184 
    return True
5185 
 
5186 
  def process_createTransaction(self, seqid, iprot, oprot):
5187 
    args = createTransaction_args()
5188 
    args.read(iprot)
5189 
    iprot.readMessageEnd()
5190 
    result = createTransaction_result()
5191 
    try:
132 ashish 5192 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 5193 
    except TransactionServiceException, ex:
5194 
      result.ex = ex
5195 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
5196 
    result.write(oprot)
5197 
    oprot.writeMessageEnd()
5198 
    oprot.trans.flush()
5199 
 
5200 
  def process_getTransaction(self, seqid, iprot, oprot):
5201 
    args = getTransaction_args()
5202 
    args.read(iprot)
5203 
    iprot.readMessageEnd()
5204 
    result = getTransaction_result()
5205 
    try:
5206 
      result.success = self._handler.getTransaction(args.id)
5207 
    except TransactionServiceException, ex:
5208 
      result.ex = ex
5209 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
5210 
    result.write(oprot)
5211 
    oprot.writeMessageEnd()
5212 
    oprot.trans.flush()
5213 
 
5214 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
5215 
    args = getTransactionsForCustomer_args()
5216 
    args.read(iprot)
5217 
    iprot.readMessageEnd()
5218 
    result = getTransactionsForCustomer_result()
5219 
    try:
5220 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
5221 
    except TransactionServiceException, ex:
5222 
      result.ex = ex
5223 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
5224 
    result.write(oprot)
5225 
    oprot.writeMessageEnd()
5226 
    oprot.trans.flush()
5227 
 
132 ashish 5228 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
5229 
    args = getTransactionsForShoppingCartId_args()
5230 
    args.read(iprot)
5231 
    iprot.readMessageEnd()
5232 
    result = getTransactionsForShoppingCartId_result()
5233 
    try:
5234 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
5235 
    except TransactionServiceException, ex:
5236 
      result.ex = ex
5237 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
5238 
    result.write(oprot)
5239 
    oprot.writeMessageEnd()
5240 
    oprot.trans.flush()
5241 
 
94 ashish 5242 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
5243 
    args = getTransactionStatus_args()
5244 
    args.read(iprot)
5245 
    iprot.readMessageEnd()
5246 
    result = getTransactionStatus_result()
5247 
    try:
5248 
      result.success = self._handler.getTransactionStatus(args.transactionId)
5249 
    except TransactionServiceException, ex:
5250 
      result.ex = ex
5251 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
5252 
    result.write(oprot)
5253 
    oprot.writeMessageEnd()
5254 
    oprot.trans.flush()
5255 
 
5256 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
5257 
    args = changeTransactionStatus_args()
5258 
    args.read(iprot)
5259 
    iprot.readMessageEnd()
5260 
    result = changeTransactionStatus_result()
5261 
    try:
5262 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
5263 
    except TransactionServiceException, ex:
5264 
      result.ex = ex
5265 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
5266 
    result.write(oprot)
5267 
    oprot.writeMessageEnd()
5268 
    oprot.trans.flush()
5269 
 
1398 varun.gupt 5270 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
5271 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 5272 
    args.read(iprot)
5273 
    iprot.readMessageEnd()
1398 varun.gupt 5274 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 5275 
    try:
1398 varun.gupt 5276 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 5277 
    except TransactionServiceException, ex:
5278 
      result.ex = ex
1398 varun.gupt 5279 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 5280 
    result.write(oprot)
5281 
    oprot.writeMessageEnd()
5282 
    oprot.trans.flush()
5283 
 
483 rajveer 5284 
  def process_getAllOrders(self, seqid, iprot, oprot):
5285 
    args = getAllOrders_args()
94 ashish 5286 
    args.read(iprot)
5287 
    iprot.readMessageEnd()
483 rajveer 5288 
    result = getAllOrders_result()
94 ashish 5289 
    try:
4801 anupam.sin 5290 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 5291 
    except TransactionServiceException, ex:
5292 
      result.ex = ex
483 rajveer 5293 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 5294 
    result.write(oprot)
5295 
    oprot.writeMessageEnd()
5296 
    oprot.trans.flush()
5297 
 
4133 chandransh 5298 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
5299 
    args = getOrdersInBatch_args()
5300 
    args.read(iprot)
5301 
    iprot.readMessageEnd()
5302 
    result = getOrdersInBatch_result()
5303 
    try:
5304 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
5305 
    except TransactionServiceException, ex:
5306 
      result.ex = ex
5307 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
5308 
    result.write(oprot)
5309 
    oprot.writeMessageEnd()
5310 
    oprot.trans.flush()
5311 
 
5312 
  def process_getOrderCount(self, seqid, iprot, oprot):
5313 
    args = getOrderCount_args()
5314 
    args.read(iprot)
5315 
    iprot.readMessageEnd()
5316 
    result = getOrderCount_result()
5317 
    try:
5318 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
5319 
    except TransactionServiceException, ex:
5320 
      result.ex = ex
5321 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
5322 
    result.write(oprot)
5323 
    oprot.writeMessageEnd()
5324 
    oprot.trans.flush()
5325 
 
999 varun.gupt 5326 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
5327 
    args = getOrdersByBillingDate_args()
5328 
    args.read(iprot)
5329 
    iprot.readMessageEnd()
5330 
    result = getOrdersByBillingDate_result()
5331 
    try:
5332 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
5333 
    except TransactionServiceException, ex:
5334 
      result.ex = ex
5335 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
5336 
    result.write(oprot)
5337 
    oprot.writeMessageEnd()
5338 
    oprot.trans.flush()
5339 
 
3427 chandransh 5340 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
5341 
    args = getOrdersByShippingDate_args()
5342 
    args.read(iprot)
5343 
    iprot.readMessageEnd()
5344 
    result = getOrdersByShippingDate_result()
5345 
    try:
3451 chandransh 5346 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 5347 
    except TransactionServiceException, ex:
5348 
      result.ex = ex
5349 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
5350 
    result.write(oprot)
5351 
    oprot.writeMessageEnd()
5352 
    oprot.trans.flush()
5353 
 
1382 varun.gupt 5354 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
5355 
    args = getReturnableOrdersForCustomer_args()
5356 
    args.read(iprot)
5357 
    iprot.readMessageEnd()
5358 
    result = getReturnableOrdersForCustomer_result()
5359 
    try:
5360 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
5361 
    except TransactionServiceException, ex:
5362 
      result.ex = ex
5363 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
5364 
    result.write(oprot)
5365 
    oprot.writeMessageEnd()
5366 
    oprot.trans.flush()
5367 
 
5368 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
5369 
    args = getCancellableOrdersForCustomer_args()
5370 
    args.read(iprot)
5371 
    iprot.readMessageEnd()
5372 
    result = getCancellableOrdersForCustomer_result()
5373 
    try:
5374 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
5375 
    except TransactionServiceException, ex:
5376 
      result.ex = ex
5377 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
5378 
    result.write(oprot)
5379 
    oprot.writeMessageEnd()
5380 
    oprot.trans.flush()
5381 
 
483 rajveer 5382 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
5383 
    args = changeOrderStatus_args()
94 ashish 5384 
    args.read(iprot)
5385 
    iprot.readMessageEnd()
483 rajveer 5386 
    result = changeOrderStatus_result()
94 ashish 5387 
    try:
483 rajveer 5388 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 5389 
    except TransactionServiceException, ex:
5390 
      result.ex = ex
483 rajveer 5391 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 5392 
    result.write(oprot)
5393 
    oprot.writeMessageEnd()
5394 
    oprot.trans.flush()
5395 
 
483 rajveer 5396 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
5397 
    args = getOrdersForTransaction_args()
94 ashish 5398 
    args.read(iprot)
5399 
    iprot.readMessageEnd()
483 rajveer 5400 
    result = getOrdersForTransaction_result()
94 ashish 5401 
    try:
1528 ankur.sing 5402 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 5403 
    except TransactionServiceException, ex:
5404 
      result.ex = ex
483 rajveer 5405 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 5406 
    result.write(oprot)
5407 
    oprot.writeMessageEnd()
5408 
    oprot.trans.flush()
5409 
 
483 rajveer 5410 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
5411 
    args = getOrdersForCustomer_args()
94 ashish 5412 
    args.read(iprot)
5413 
    iprot.readMessageEnd()
483 rajveer 5414 
    result = getOrdersForCustomer_result()
94 ashish 5415 
    try:
3014 chandransh 5416 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 5417 
    except TransactionServiceException, ex:
5418 
      result.ex = ex
483 rajveer 5419 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 5420 
    result.write(oprot)
5421 
    oprot.writeMessageEnd()
5422 
    oprot.trans.flush()
5423 
 
483 rajveer 5424 
  def process_createOrder(self, seqid, iprot, oprot):
5425 
    args = createOrder_args()
94 ashish 5426 
    args.read(iprot)
5427 
    iprot.readMessageEnd()
483 rajveer 5428 
    result = createOrder_result()
94 ashish 5429 
    try:
483 rajveer 5430 
      result.success = self._handler.createOrder(args.order)
94 ashish 5431 
    except TransactionServiceException, ex:
5432 
      result.ex = ex
483 rajveer 5433 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 5434 
    result.write(oprot)
5435 
    oprot.writeMessageEnd()
5436 
    oprot.trans.flush()
5437 
 
483 rajveer 5438 
  def process_getOrder(self, seqid, iprot, oprot):
5439 
    args = getOrder_args()
94 ashish 5440 
    args.read(iprot)
5441 
    iprot.readMessageEnd()
483 rajveer 5442 
    result = getOrder_result()
94 ashish 5443 
    try:
483 rajveer 5444 
      result.success = self._handler.getOrder(args.id)
94 ashish 5445 
    except TransactionServiceException, ex:
5446 
      result.ex = ex
483 rajveer 5447 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 5448 
    result.write(oprot)
5449 
    oprot.writeMessageEnd()
5450 
    oprot.trans.flush()
5451 
 
483 rajveer 5452 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
5453 
    args = getLineItemsForOrder_args()
94 ashish 5454 
    args.read(iprot)
5455 
    iprot.readMessageEnd()
483 rajveer 5456 
    result = getLineItemsForOrder_result()
94 ashish 5457 
    try:
483 rajveer 5458 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 5459 
    except TransactionServiceException, ex:
5460 
      result.ex = ex
483 rajveer 5461 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 5462 
    result.write(oprot)
5463 
    oprot.writeMessageEnd()
5464 
    oprot.trans.flush()
5465 
 
4999 phani.kuma 5466 
  def process_getOrderList(self, seqid, iprot, oprot):
5467 
    args = getOrderList_args()
5468 
    args.read(iprot)
5469 
    iprot.readMessageEnd()
5470 
    result = getOrderList_result()
5471 
    result.success = self._handler.getOrderList(args.order_ids)
5472 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
5473 
    result.write(oprot)
5474 
    oprot.writeMessageEnd()
5475 
    oprot.trans.flush()
5476 
 
1528 ankur.sing 5477 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
5478 
    args = getOrderForCustomer_args()
5479 
    args.read(iprot)
5480 
    iprot.readMessageEnd()
5481 
    result = getOrderForCustomer_result()
5482 
    try:
5483 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
5484 
    except TransactionServiceException, ex:
5485 
      result.ex = ex
5486 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
5487 
    result.write(oprot)
5488 
    oprot.writeMessageEnd()
5489 
    oprot.trans.flush()
5490 
 
3064 chandransh 5491 
  def process_getAlerts(self, seqid, iprot, oprot):
5492 
    args = getAlerts_args()
5493 
    args.read(iprot)
5494 
    iprot.readMessageEnd()
5495 
    result = getAlerts_result()
4444 rajveer 5496 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 5497 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
5498 
    result.write(oprot)
5499 
    oprot.writeMessageEnd()
5500 
    oprot.trans.flush()
5501 
 
4394 rajveer 5502 
  def process_addAlert(self, seqid, iprot, oprot):
5503 
    args = addAlert_args()
3064 chandransh 5504 
    args.read(iprot)
5505 
    iprot.readMessageEnd()
4394 rajveer 5506 
    result = addAlert_result()
4444 rajveer 5507 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 5508 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 5509 
    result.write(oprot)
5510 
    oprot.writeMessageEnd()
5511 
    oprot.trans.flush()
5512 
 
4444 rajveer 5513 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
5514 
    args = markAlertsAsSeen_args()
5515 
    args.read(iprot)
5516 
    iprot.readMessageEnd()
5517 
    result = markAlertsAsSeen_result()
5518 
    self._handler.markAlertsAsSeen(args.warehouseId)
5519 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
5520 
    result.write(oprot)
5521 
    oprot.writeMessageEnd()
5522 
    oprot.trans.flush()
5523 
 
3064 chandransh 5524 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
5525 
    args = getValidOrderCount_args()
5526 
    args.read(iprot)
5527 
    iprot.readMessageEnd()
5528 
    result = getValidOrderCount_result()
5529 
    result.success = self._handler.getValidOrderCount()
5530 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
5531 
    result.write(oprot)
5532 
    oprot.writeMessageEnd()
5533 
    oprot.trans.flush()
5534 
 
5535 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
5536 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
5537 
    args.read(iprot)
5538 
    iprot.readMessageEnd()
5539 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
5540 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
5541 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
5542 
    result.write(oprot)
5543 
    oprot.writeMessageEnd()
5544 
    oprot.trans.flush()
5545 
 
5546 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
5547 
    args = getValidOrdersAmountRange_args()
5548 
    args.read(iprot)
5549 
    iprot.readMessageEnd()
5550 
    result = getValidOrdersAmountRange_result()
5551 
    result.success = self._handler.getValidOrdersAmountRange()
5552 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
5553 
    result.write(oprot)
5554 
    oprot.writeMessageEnd()
5555 
    oprot.trans.flush()
5556 
 
5557 
  def process_getValidOrders(self, seqid, iprot, oprot):
5558 
    args = getValidOrders_args()
5559 
    args.read(iprot)
5560 
    iprot.readMessageEnd()
5561 
    result = getValidOrders_result()
5562 
    result.success = self._handler.getValidOrders(args.limit)
5563 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
5564 
    result.write(oprot)
5565 
    oprot.writeMessageEnd()
5566 
    oprot.trans.flush()
5567 
 
1220 chandransh 5568 
  def process_batchOrders(self, seqid, iprot, oprot):
5569 
    args = batchOrders_args()
5570 
    args.read(iprot)
5571 
    iprot.readMessageEnd()
5572 
    result = batchOrders_result()
5573 
    try:
5574 
      result.success = self._handler.batchOrders(args.warehouseId)
5575 
    except TransactionServiceException, ex:
5576 
      result.ex = ex
5577 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
5578 
    result.write(oprot)
5579 
    oprot.writeMessageEnd()
5580 
    oprot.trans.flush()
5581 
 
1208 chandransh 5582 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
5583 
    args = markOrderAsOutOfStock_args()
5584 
    args.read(iprot)
5585 
    iprot.readMessageEnd()
5586 
    result = markOrderAsOutOfStock_result()
5587 
    try:
5588 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
5589 
    except TransactionServiceException, ex:
5590 
      result.ex = ex
5591 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
5592 
    result.write(oprot)
5593 
    oprot.writeMessageEnd()
5594 
    oprot.trans.flush()
5595 
 
3064 chandransh 5596 
  def process_verifyOrder(self, seqid, iprot, oprot):
5597 
    args = verifyOrder_args()
759 chandransh 5598 
    args.read(iprot)
5599 
    iprot.readMessageEnd()
3064 chandransh 5600 
    result = verifyOrder_result()
759 chandransh 5601 
    try:
3064 chandransh 5602 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 5603 
    except TransactionServiceException, ex:
5604 
      result.ex = ex
3064 chandransh 5605 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 5606 
    result.write(oprot)
5607 
    oprot.writeMessageEnd()
5608 
    oprot.trans.flush()
5609 
 
3064 chandransh 5610 
  def process_acceptOrder(self, seqid, iprot, oprot):
5611 
    args = acceptOrder_args()
1113 chandransh 5612 
    args.read(iprot)
5613 
    iprot.readMessageEnd()
3064 chandransh 5614 
    result = acceptOrder_result()
1113 chandransh 5615 
    try:
3064 chandransh 5616 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 5617 
    except TransactionServiceException, ex:
5618 
      result.ex = ex
3064 chandransh 5619 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 5620 
    result.write(oprot)
5621 
    oprot.writeMessageEnd()
5622 
    oprot.trans.flush()
5623 
 
3064 chandransh 5624 
  def process_addBillingDetails(self, seqid, iprot, oprot):
5625 
    args = addBillingDetails_args()
1135 chandransh 5626 
    args.read(iprot)
5627 
    iprot.readMessageEnd()
3064 chandransh 5628 
    result = addBillingDetails_result()
1135 chandransh 5629 
    try:
5110 mandeep.dh 5630 
      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 5631 
    except TransactionServiceException, ex:
5632 
      result.ex = ex
3064 chandransh 5633 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 5634 
    result.write(oprot)
5635 
    oprot.writeMessageEnd()
5636 
    oprot.trans.flush()
5637 
 
4579 rajveer 5638 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
5639 
    args = addInvoiceNumber_args()
5640 
    args.read(iprot)
5641 
    iprot.readMessageEnd()
5642 
    result = addInvoiceNumber_result()
5643 
    try:
4763 rajveer 5644 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 5645 
    except TransactionServiceException, ex:
5646 
      result.ex = ex
5647 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
5648 
    result.write(oprot)
5649 
    oprot.writeMessageEnd()
5650 
    oprot.trans.flush()
5651 
 
4410 rajveer 5652 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5653 
    args = markOrdersAsShippedFromWarehouse_args()
5654 
    args.read(iprot)
5655 
    iprot.readMessageEnd()
5656 
    result = markOrdersAsShippedFromWarehouse_result()
5657 
    try:
4789 rajveer 5658 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 5659 
    except TransactionServiceException, ex:
5660 
      result.ex = ex
5661 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5662 
    result.write(oprot)
5663 
    oprot.writeMessageEnd()
5664 
    oprot.trans.flush()
5665 
 
3064 chandransh 5666 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5667 
    args = markOrdersAsPickedUp_args()
304 ashish 5668 
    args.read(iprot)
5669 
    iprot.readMessageEnd()
3064 chandransh 5670 
    result = markOrdersAsPickedUp_result()
5671 
    try:
4910 phani.kuma 5672 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 5673 
    except TransactionServiceException, ex:
5674 
      result.ex = ex
5675 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5676 
    result.write(oprot)
5677 
    oprot.writeMessageEnd()
5678 
    oprot.trans.flush()
94 ashish 5679 
 
4910 phani.kuma 5680 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
5681 
    args = getOrdersNotPickedUp_args()
5682 
    args.read(iprot)
5683 
    iprot.readMessageEnd()
5684 
    result = getOrdersNotPickedUp_result()
5685 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
5686 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
5687 
    result.write(oprot)
5688 
    oprot.writeMessageEnd()
5689 
    oprot.trans.flush()
5690 
 
3064 chandransh 5691 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5692 
    args = markOrdersAsDelivered_args()
304 ashish 5693 
    args.read(iprot)
5694 
    iprot.readMessageEnd()
3064 chandransh 5695 
    result = markOrdersAsDelivered_result()
5696 
    try:
5697 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5698 
    except TransactionServiceException, ex:
5699 
      result.ex = ex
5700 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5701 
    result.write(oprot)
5702 
    oprot.writeMessageEnd()
5703 
    oprot.trans.flush()
5704 
 
4910 phani.kuma 5705 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
5706 
    args = markAsRTOrders_args()
1596 ankur.sing 5707 
    args.read(iprot)
5708 
    iprot.readMessageEnd()
4910 phani.kuma 5709 
    result = markAsRTOrders_result()
3064 chandransh 5710 
    try:
4910 phani.kuma 5711 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 5712 
    except TransactionServiceException, ex:
5713 
      result.ex = ex
4910 phani.kuma 5714 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 5715 
    result.write(oprot)
5716 
    oprot.writeMessageEnd()
5717 
    oprot.trans.flush()
304 ashish 5718 
 
4910 phani.kuma 5719 
  def process_getRTOrders(self, seqid, iprot, oprot):
5720 
    args = getRTOrders_args()
5721 
    args.read(iprot)
5722 
    iprot.readMessageEnd()
5723 
    result = getRTOrders_result()
5724 
    result.success = self._handler.getRTOrders(args.providerId)
5725 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
5726 
    result.write(oprot)
5727 
    oprot.writeMessageEnd()
5728 
    oprot.trans.flush()
5729 
 
3064 chandransh 5730 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5731 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5732 
    args.read(iprot)
5733 
    iprot.readMessageEnd()
3064 chandransh 5734 
    result = updateNonDeliveryReason_result()
5735 
    try:
4910 phani.kuma 5736 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5737 
    except TransactionServiceException, ex:
5738 
      result.ex = ex
5739 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5740 
    result.write(oprot)
5741 
    oprot.writeMessageEnd()
5742 
    oprot.trans.flush()
1596 ankur.sing 5743 
 
4910 phani.kuma 5744 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
5745 
    args = getNonDeliveredOrdersbyCourier_args()
5746 
    args.read(iprot)
5747 
    iprot.readMessageEnd()
5748 
    result = getNonDeliveredOrdersbyCourier_result()
5749 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
5750 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
5751 
    result.write(oprot)
5752 
    oprot.writeMessageEnd()
5753 
    oprot.trans.flush()
5754 
 
5755 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
5756 
    args = markOrdersAsLocalConnected_args()
5757 
    args.read(iprot)
5758 
    iprot.readMessageEnd()
5759 
    result = markOrdersAsLocalConnected_result()
5760 
    try:
5761 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
5762 
    except TransactionServiceException, ex:
5763 
      result.ex = ex
5764 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
5765 
    result.write(oprot)
5766 
    oprot.writeMessageEnd()
5767 
    oprot.trans.flush()
5768 
 
5769 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
5770 
    args = getOrdersNotLocalConnected_args()
5771 
    args.read(iprot)
5772 
    iprot.readMessageEnd()
5773 
    result = getOrdersNotLocalConnected_result()
5774 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
5775 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
5776 
    result.write(oprot)
5777 
    oprot.writeMessageEnd()
5778 
    oprot.trans.flush()
5779 
 
5780 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
5781 
    args = markOrdersAsDestinationCityReached_args()
5782 
    args.read(iprot)
5783 
    iprot.readMessageEnd()
5784 
    result = markOrdersAsDestinationCityReached_result()
5785 
    try:
5786 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
5787 
    except TransactionServiceException, ex:
5788 
      result.ex = ex
5789 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
5790 
    result.write(oprot)
5791 
    oprot.writeMessageEnd()
5792 
    oprot.trans.flush()
5793 
 
5794 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
5795 
    args = markOrdersAsFirstDeliveryAttempted_args()
5796 
    args.read(iprot)
5797 
    iprot.readMessageEnd()
5798 
    result = markOrdersAsFirstDeliveryAttempted_result()
5799 
    try:
5800 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
5801 
    except TransactionServiceException, ex:
5802 
      result.ex = ex
5803 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
5804 
    result.write(oprot)
5805 
    oprot.writeMessageEnd()
5806 
    oprot.trans.flush()
5807 
 
3064 chandransh 5808 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5809 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5810 
    args.read(iprot)
5811 
    iprot.readMessageEnd()
3064 chandransh 5812 
    result = getUndeliveredOrders_result()
5813 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5814 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5815 
    result.write(oprot)
5816 
    oprot.writeMessageEnd()
5817 
    oprot.trans.flush()
5818 
 
4783 phani.kuma 5819 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
5820 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
5821 
    args.read(iprot)
5822 
    iprot.readMessageEnd()
5823 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
5824 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
5825 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
5826 
    result.write(oprot)
5827 
    oprot.writeMessageEnd()
5828 
    oprot.trans.flush()
5829 
 
2536 chandransh 5830 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5831 
    args = toggleDOAFlag_args()
5832 
    args.read(iprot)
5833 
    iprot.readMessageEnd()
5834 
    result = toggleDOAFlag_result()
5835 
    try:
5836 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5837 
    except TransactionServiceException, ex:
5838 
      result.ex = ex
5839 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5840 
    result.write(oprot)
5841 
    oprot.writeMessageEnd()
5842 
    oprot.trans.flush()
1886 ankur.sing 5843 
 
4712 rajveer 5844 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5845 
    args = markOrderAsDelivered_args()
5846 
    args.read(iprot)
5847 
    iprot.readMessageEnd()
5848 
    result = markOrderAsDelivered_result()
5849 
    try:
5850 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5851 
    except TransactionServiceException, ex:
5852 
      result.ex = ex
5853 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5854 
    result.write(oprot)
5855 
    oprot.writeMessageEnd()
5856 
    oprot.trans.flush()
5857 
 
4454 rajveer 5858 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5859 
    args = markOrderDoaRequestReceived_args()
5860 
    args.read(iprot)
5861 
    iprot.readMessageEnd()
5862 
    result = markOrderDoaRequestReceived_result()
5863 
    try:
5864 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5865 
    except TransactionServiceException, ex:
5866 
      result.ex = ex
5867 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5868 
    result.write(oprot)
5869 
    oprot.writeMessageEnd()
5870 
    oprot.trans.flush()
5871 
 
5872 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
5873 
    args = markOrderDoaRequestAuthorized_args()
5874 
    args.read(iprot)
5875 
    iprot.readMessageEnd()
5876 
    result = markOrderDoaRequestAuthorized_result()
5877 
    try:
5878 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
5879 
    except TransactionServiceException, ex:
5880 
      result.ex = ex
5881 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
5882 
    result.write(oprot)
5883 
    oprot.writeMessageEnd()
5884 
    oprot.trans.flush()
5885 
 
4488 rajveer 5886 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5887 
    args = markOrderReturnRequestReceived_args()
5888 
    args.read(iprot)
5889 
    iprot.readMessageEnd()
5890 
    result = markOrderReturnRequestReceived_result()
5891 
    try:
5892 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5893 
    except TransactionServiceException, ex:
5894 
      result.ex = ex
5895 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5896 
    result.write(oprot)
5897 
    oprot.writeMessageEnd()
5898 
    oprot.trans.flush()
5899 
 
5900 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5901 
    args = markOrderReturnRequestAuthorized_args()
5902 
    args.read(iprot)
5903 
    iprot.readMessageEnd()
5904 
    result = markOrderReturnRequestAuthorized_result()
5905 
    try:
5906 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5907 
    except TransactionServiceException, ex:
5908 
      result.ex = ex
5909 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5910 
    result.write(oprot)
5911 
    oprot.writeMessageEnd()
5912 
    oprot.trans.flush()
5913 
 
2536 chandransh 5914 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5915 
    args = requestPickupNumber_args()
5916 
    args.read(iprot)
5917 
    iprot.readMessageEnd()
5918 
    result = requestPickupNumber_result()
5919 
    try:
4579 rajveer 5920 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 5921 
    except TransactionServiceException, ex:
5922 
      result.ex = ex
5923 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
5924 
    result.write(oprot)
5925 
    oprot.writeMessageEnd()
5926 
    oprot.trans.flush()
5927 
 
5928 
  def process_authorizePickup(self, seqid, iprot, oprot):
5929 
    args = authorizePickup_args()
5930 
    args.read(iprot)
5931 
    iprot.readMessageEnd()
5932 
    result = authorizePickup_result()
5933 
    try:
4602 rajveer 5934 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 5935 
    except TransactionServiceException, ex:
5936 
      result.ex = ex
5937 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
5938 
    result.write(oprot)
5939 
    oprot.writeMessageEnd()
5940 
    oprot.trans.flush()
5941 
 
2764 chandransh 5942 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
5943 
    args = markDoasAsPickedUp_args()
5944 
    args.read(iprot)
5945 
    iprot.readMessageEnd()
5946 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 5947 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 5948 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
5949 
    result.write(oprot)
5950 
    oprot.writeMessageEnd()
5951 
    oprot.trans.flush()
5952 
 
4910 phani.kuma 5953 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
5954 
    args = getDoasNotPickedUp_args()
5955 
    args.read(iprot)
5956 
    iprot.readMessageEnd()
5957 
    result = getDoasNotPickedUp_result()
5958 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
5959 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
5960 
    result.write(oprot)
5961 
    oprot.writeMessageEnd()
5962 
    oprot.trans.flush()
5963 
 
4741 phani.kuma 5964 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
5965 
    args = markReturnOrdersAsPickedUp_args()
5966 
    args.read(iprot)
5967 
    iprot.readMessageEnd()
5968 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 5969 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 5970 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
5971 
    result.write(oprot)
5972 
    oprot.writeMessageEnd()
5973 
    oprot.trans.flush()
5974 
 
4910 phani.kuma 5975 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
5976 
    args = getReturnOrdersNotPickedUp_args()
5977 
    args.read(iprot)
5978 
    iprot.readMessageEnd()
5979 
    result = getReturnOrdersNotPickedUp_result()
5980 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
5981 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
5982 
    result.write(oprot)
5983 
    oprot.writeMessageEnd()
5984 
    oprot.trans.flush()
5985 
 
2616 chandransh 5986 
  def process_receiveReturn(self, seqid, iprot, oprot):
5987 
    args = receiveReturn_args()
2591 chandransh 5988 
    args.read(iprot)
5989 
    iprot.readMessageEnd()
2616 chandransh 5990 
    result = receiveReturn_result()
2591 chandransh 5991 
    try:
4479 rajveer 5992 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 5993 
    except TransactionServiceException, ex:
5994 
      result.ex = ex
2616 chandransh 5995 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 5996 
    result.write(oprot)
5997 
    oprot.writeMessageEnd()
5998 
    oprot.trans.flush()
2536 chandransh 5999 
 
2591 chandransh 6000 
  def process_validateDoa(self, seqid, iprot, oprot):
6001 
    args = validateDoa_args()
6002 
    args.read(iprot)
6003 
    iprot.readMessageEnd()
6004 
    result = validateDoa_result()
6005 
    try:
6006 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
6007 
    except TransactionServiceException, ex:
6008 
      result.ex = ex
6009 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
6010 
    result.write(oprot)
6011 
    oprot.writeMessageEnd()
6012 
    oprot.trans.flush()
6013 
 
4495 rajveer 6014 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
6015 
    args = validateReturnProduct_args()
6016 
    args.read(iprot)
6017 
    iprot.readMessageEnd()
6018 
    result = validateReturnProduct_result()
6019 
    try:
6020 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
6021 
    except TransactionServiceException, ex:
6022 
      result.ex = ex
6023 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
6024 
    result.write(oprot)
6025 
    oprot.writeMessageEnd()
6026 
    oprot.trans.flush()
6027 
 
2616 chandransh 6028 
  def process_reshipOrder(self, seqid, iprot, oprot):
6029 
    args = reshipOrder_args()
6030 
    args.read(iprot)
6031 
    iprot.readMessageEnd()
6032 
    result = reshipOrder_result()
6033 
    try:
6034 
      result.success = self._handler.reshipOrder(args.orderId)
6035 
    except TransactionServiceException, ex:
6036 
      result.ex = ex
6037 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
6038 
    result.write(oprot)
6039 
    oprot.writeMessageEnd()
6040 
    oprot.trans.flush()
2591 chandransh 6041 
 
2616 chandransh 6042 
  def process_refundOrder(self, seqid, iprot, oprot):
6043 
    args = refundOrder_args()
6044 
    args.read(iprot)
6045 
    iprot.readMessageEnd()
6046 
    result = refundOrder_result()
6047 
    try:
3226 chandransh 6048 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 6049 
    except TransactionServiceException, ex:
6050 
      result.ex = ex
6051 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
6052 
    result.write(oprot)
6053 
    oprot.writeMessageEnd()
6054 
    oprot.trans.flush()
6055 
 
2690 chandransh 6056 
  def process_getReturnOrders(self, seqid, iprot, oprot):
6057 
    args = getReturnOrders_args()
6058 
    args.read(iprot)
6059 
    iprot.readMessageEnd()
6060 
    result = getReturnOrders_result()
6061 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
6062 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
6063 
    result.write(oprot)
6064 
    oprot.writeMessageEnd()
6065 
    oprot.trans.flush()
2616 chandransh 6066 
 
2700 chandransh 6067 
  def process_getReturnOrder(self, seqid, iprot, oprot):
6068 
    args = getReturnOrder_args()
6069 
    args.read(iprot)
6070 
    iprot.readMessageEnd()
6071 
    result = getReturnOrder_result()
6072 
    try:
6073 
      result.success = self._handler.getReturnOrder(args.id)
6074 
    except TransactionServiceException, ex:
6075 
      result.ex = ex
6076 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
6077 
    result.write(oprot)
6078 
    oprot.writeMessageEnd()
6079 
    oprot.trans.flush()
6080 
 
2690 chandransh 6081 
  def process_processReturn(self, seqid, iprot, oprot):
6082 
    args = processReturn_args()
6083 
    args.read(iprot)
6084 
    iprot.readMessageEnd()
6085 
    result = processReturn_result()
6086 
    try:
6087 
      self._handler.processReturn(args.returnOrderId)
6088 
    except TransactionServiceException, ex:
6089 
      result.ex = ex
6090 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
6091 
    result.write(oprot)
6092 
    oprot.writeMessageEnd()
6093 
    oprot.trans.flush()
6094 
 
3451 chandransh 6095 
  def process_updateWeight(self, seqid, iprot, oprot):
6096 
    args = updateWeight_args()
6097 
    args.read(iprot)
6098 
    iprot.readMessageEnd()
6099 
    result = updateWeight_result()
6100 
    try:
6101 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
6102 
    except TransactionServiceException, ex:
6103 
      result.ex = ex
6104 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
6105 
    result.write(oprot)
6106 
    oprot.writeMessageEnd()
6107 
    oprot.trans.flush()
2819 chandransh 6108 
 
3469 chandransh 6109 
  def process_changeItem(self, seqid, iprot, oprot):
6110 
    args = changeItem_args()
6111 
    args.read(iprot)
6112 
    iprot.readMessageEnd()
6113 
    result = changeItem_result()
6114 
    try:
6115 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
6116 
    except TransactionServiceException, ex:
6117 
      result.ex = ex
6118 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
6119 
    result.write(oprot)
6120 
    oprot.writeMessageEnd()
6121 
    oprot.trans.flush()
3451 chandransh 6122 
 
3469 chandransh 6123 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
6124 
    args = shiftToWarehouse_args()
6125 
    args.read(iprot)
6126 
    iprot.readMessageEnd()
6127 
    result = shiftToWarehouse_result()
6128 
    try:
6129 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
6130 
    except TransactionServiceException, ex:
6131 
      result.ex = ex
6132 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
6133 
    result.write(oprot)
6134 
    oprot.writeMessageEnd()
6135 
    oprot.trans.flush()
6136 
 
3553 chandransh 6137 
  def process_addDelayReason(self, seqid, iprot, oprot):
6138 
    args = addDelayReason_args()
6139 
    args.read(iprot)
6140 
    iprot.readMessageEnd()
6141 
    result = addDelayReason_result()
6142 
    try:
4647 rajveer 6143 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 6144 
    except TransactionServiceException, ex:
6145 
      result.ex = ex
6146 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
6147 
    result.write(oprot)
6148 
    oprot.writeMessageEnd()
6149 
    oprot.trans.flush()
3469 chandransh 6150 
 
3956 chandransh 6151 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
6152 
    args = reconcileCodCollection_args()
6153 
    args.read(iprot)
6154 
    iprot.readMessageEnd()
6155 
    result = reconcileCodCollection_result()
6156 
    try:
6157 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
6158 
    except TransactionServiceException, ex:
6159 
      result.ex = ex
6160 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
6161 
    result.write(oprot)
6162 
    oprot.writeMessageEnd()
6163 
    oprot.trans.flush()
3553 chandransh 6164 
 
4008 mandeep.dh 6165 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
6166 
    args = getTransactionsRequiringExtraProcessing_args()
6167 
    args.read(iprot)
6168 
    iprot.readMessageEnd()
6169 
    result = getTransactionsRequiringExtraProcessing_result()
6170 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
6171 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
6172 
    result.write(oprot)
6173 
    oprot.writeMessageEnd()
6174 
    oprot.trans.flush()
3956 chandransh 6175 
 
4008 mandeep.dh 6176 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
6177 
    args = markTransactionAsProcessed_args()
6178 
    args.read(iprot)
6179 
    iprot.readMessageEnd()
6180 
    result = markTransactionAsProcessed_result()
6181 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
6182 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
6183 
    result.write(oprot)
6184 
    oprot.writeMessageEnd()
6185 
    oprot.trans.flush()
6186 
 
4018 chandransh 6187 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
6188 
    args = getItemWiseRiskyOrdersCount_args()
6189 
    args.read(iprot)
6190 
    iprot.readMessageEnd()
6191 
    result = getItemWiseRiskyOrdersCount_result()
6192 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
6193 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
6194 
    result.write(oprot)
6195 
    oprot.writeMessageEnd()
6196 
    oprot.trans.flush()
4008 mandeep.dh 6197 
 
4295 varun.gupt 6198 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
6199 
    args = getOrdersForItemIds_args()
6200 
    args.read(iprot)
6201 
    iprot.readMessageEnd()
6202 
    result = getOrdersForItemIds_result()
6203 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
6204 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
6205 
    result.write(oprot)
6206 
    oprot.writeMessageEnd()
6207 
    oprot.trans.flush()
6208 
 
4247 rajveer 6209 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
6210 
    args = markOrderCancellationRequestReceived_args()
6211 
    args.read(iprot)
6212 
    iprot.readMessageEnd()
6213 
    result = markOrderCancellationRequestReceived_result()
6214 
    try:
6215 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
6216 
    except TransactionServiceException, ex:
6217 
      result.ex = ex
6218 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
6219 
    result.write(oprot)
6220 
    oprot.writeMessageEnd()
6221 
    oprot.trans.flush()
4018 chandransh 6222 
 
4247 rajveer 6223 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
6224 
    args = markOrderCancellationRequestConfirmed_args()
6225 
    args.read(iprot)
6226 
    iprot.readMessageEnd()
6227 
    result = markOrderCancellationRequestConfirmed_result()
6228 
    try:
6229 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
6230 
    except TransactionServiceException, ex:
6231 
      result.ex = ex
6232 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
6233 
    result.write(oprot)
6234 
    oprot.writeMessageEnd()
6235 
    oprot.trans.flush()
6236 
 
6237 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
6238 
    args = markOrderCancellationRequestDenied_args()
6239 
    args.read(iprot)
6240 
    iprot.readMessageEnd()
6241 
    result = markOrderCancellationRequestDenied_result()
6242 
    try:
6243 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
6244 
    except TransactionServiceException, ex:
6245 
      result.ex = ex
6246 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
6247 
    result.write(oprot)
6248 
    oprot.writeMessageEnd()
6249 
    oprot.trans.flush()
6250 
 
4258 rajveer 6251 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
6252 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 6253 
    args.read(iprot)
6254 
    iprot.readMessageEnd()
4258 rajveer 6255 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 6256 
    try:
4258 rajveer 6257 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 6258 
    except TransactionServiceException, ex:
6259 
      result.ex = ex
4258 rajveer 6260 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 6261 
    result.write(oprot)
6262 
    oprot.writeMessageEnd()
6263 
    oprot.trans.flush()
6264 
 
4259 anupam.sin 6265 
  def process_refundTransaction(self, seqid, iprot, oprot):
6266 
    args = refundTransaction_args()
6267 
    args.read(iprot)
6268 
    iprot.readMessageEnd()
6269 
    result = refundTransaction_result()
6270 
    try:
6271 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
6272 
    except TransactionServiceException, ex:
6273 
      result.ex = ex
6274 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
6275 
    result.write(oprot)
6276 
    oprot.writeMessageEnd()
6277 
    oprot.trans.flush()
4247 rajveer 6278 
 
4324 mandeep.dh 6279 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
6280 
    args = updateShipmentAddress_args()
6281 
    args.read(iprot)
6282 
    iprot.readMessageEnd()
6283 
    result = updateShipmentAddress_result()
6284 
    try:
6285 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
6286 
    except TransactionServiceException, ex:
6287 
      result.ex = ex
6288 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
6289 
    result.write(oprot)
6290 
    oprot.writeMessageEnd()
6291 
    oprot.trans.flush()
6292 
 
4285 rajveer 6293 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
6294 
    args = acceptOrdersForItemId_args()
6295 
    args.read(iprot)
6296 
    iprot.readMessageEnd()
6297 
    result = acceptOrdersForItemId_result()
6298 
    try:
6299 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
6300 
    except TransactionServiceException, ex:
6301 
      result.ex = ex
6302 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
6303 
    result.write(oprot)
6304 
    oprot.writeMessageEnd()
6305 
    oprot.trans.flush()
4259 anupam.sin 6306 
 
4303 rajveer 6307 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
6308 
    args = markOrdersAsPORaised_args()
6309 
    args.read(iprot)
6310 
    iprot.readMessageEnd()
6311 
    result = markOrdersAsPORaised_result()
6312 
    try:
4369 rajveer 6313 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6314 
    except TransactionServiceException, ex:
6315 
      result.ex = ex
6316 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
6317 
    result.write(oprot)
6318 
    oprot.writeMessageEnd()
6319 
    oprot.trans.flush()
4285 rajveer 6320 
 
4303 rajveer 6321 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
6322 
    args = markOrdersAsReversalInitiated_args()
6323 
    args.read(iprot)
6324 
    iprot.readMessageEnd()
6325 
    result = markOrdersAsReversalInitiated_result()
6326 
    try:
4369 rajveer 6327 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6328 
    except TransactionServiceException, ex:
6329 
      result.ex = ex
6330 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
6331 
    result.write(oprot)
6332 
    oprot.writeMessageEnd()
6333 
    oprot.trans.flush()
6334 
 
6335 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
6336 
    args = markOrdersAsNotAvailabke_args()
6337 
    args.read(iprot)
6338 
    iprot.readMessageEnd()
6339 
    result = markOrdersAsNotAvailabke_result()
6340 
    try:
4369 rajveer 6341 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6342 
    except TransactionServiceException, ex:
6343 
      result.ex = ex
6344 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
6345 
    result.write(oprot)
6346 
    oprot.writeMessageEnd()
6347 
    oprot.trans.flush()
6348 
 
4369 rajveer 6349 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
6350 
    args = markOrdersAsTimeout_args()
6351 
    args.read(iprot)
6352 
    iprot.readMessageEnd()
6353 
    result = markOrdersAsTimeout_result()
6354 
    try:
6355 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
6356 
    except TransactionServiceException, ex:
6357 
      result.ex = ex
6358 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
6359 
    result.write(oprot)
6360 
    oprot.writeMessageEnd()
6361 
    oprot.trans.flush()
4303 rajveer 6362 
 
4662 rajveer 6363 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
6364 
    args = markOrderAsLostInTransit_args()
6365 
    args.read(iprot)
6366 
    iprot.readMessageEnd()
6367 
    result = markOrderAsLostInTransit_result()
6368 
    try:
6369 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
6370 
    except TransactionServiceException, ex:
6371 
      result.ex = ex
6372 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
6373 
    result.write(oprot)
6374 
    oprot.writeMessageEnd()
6375 
    oprot.trans.flush()
6376 
 
4386 anupam.sin 6377 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
6378 
    args = getOrderForAwb_args()
6379 
    args.read(iprot)
6380 
    iprot.readMessageEnd()
6381 
    result = getOrderForAwb_result()
6382 
    try:
6383 
      result.success = self._handler.getOrderForAwb(args.awb)
6384 
    except TransactionServiceException, ex:
6385 
      result.ex = ex
6386 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
6387 
    result.write(oprot)
6388 
    oprot.writeMessageEnd()
6389 
    oprot.trans.flush()
4369 rajveer 6390 
 
4506 phani.kuma 6391 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
6392 
    args = getOrdersForProviderForStatus_args()
6393 
    args.read(iprot)
6394 
    iprot.readMessageEnd()
6395 
    result = getOrdersForProviderForStatus_result()
6396 
    try:
4910 phani.kuma 6397 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 6398 
    except TransactionServiceException, ex:
6399 
      result.ex = ex
6400 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
6401 
    result.write(oprot)
6402 
    oprot.writeMessageEnd()
6403 
    oprot.trans.flush()
4386 anupam.sin 6404 
 
4600 varun.gupt 6405 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
6406 
    args = getBilledOrdersForVendor_args()
6407 
    args.read(iprot)
6408 
    iprot.readMessageEnd()
6409 
    result = getBilledOrdersForVendor_result()
6410 
    try:
6411 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
6412 
    except TransactionServiceException, ex:
6413 
      result.ex = ex
6414 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
6415 
    result.write(oprot)
6416 
    oprot.writeMessageEnd()
6417 
    oprot.trans.flush()
4506 phani.kuma 6418 
 
4607 rajveer 6419 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
6420 
    args = getSlippedSippingDateOrders_args()
6421 
    args.read(iprot)
6422 
    iprot.readMessageEnd()
6423 
    result = getSlippedSippingDateOrders_result()
6424 
    try:
6425 
      result.success = self._handler.getSlippedSippingDateOrders()
6426 
    except TransactionServiceException, ex:
6427 
      result.ex = ex
6428 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
6429 
    result.write(oprot)
6430 
    oprot.writeMessageEnd()
6431 
    oprot.trans.flush()
6432 
 
4709 rajveer 6433 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
6434 
    args = getCancelledOrders_args()
6435 
    args.read(iprot)
6436 
    iprot.readMessageEnd()
6437 
    result = getCancelledOrders_result()
6438 
    try:
6439 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
6440 
    except TransactionServiceException, ex:
6441 
      result.ex = ex
6442 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
6443 
    result.write(oprot)
6444 
    oprot.writeMessageEnd()
6445 
    oprot.trans.flush()
6446 
 
4600 varun.gupt 6447 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
6448 
    args = saveBluedartSettlements_args()
6449 
    args.read(iprot)
6450 
    iprot.readMessageEnd()
6451 
    result = saveBluedartSettlements_result()
6452 
    try:
6453 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
6454 
    except TransactionServiceException, ex:
6455 
      result.ex = ex
6456 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
6457 
    result.write(oprot)
6458 
    oprot.writeMessageEnd()
6459 
    oprot.trans.flush()
6460 
 
6461 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
6462 
    args = savePaymentSettlements_args()
6463 
    args.read(iprot)
6464 
    iprot.readMessageEnd()
6465 
    result = savePaymentSettlements_result()
6466 
    try:
4905 varun.gupt 6467 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 6468 
    except TransactionServiceException, ex:
6469 
      result.ex = ex
6470 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
6471 
    result.write(oprot)
6472 
    oprot.writeMessageEnd()
6473 
    oprot.trans.flush()
6474 
 
6475 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
6476 
    args = saveEBSSettlementSummary_args()
6477 
    args.read(iprot)
6478 
    iprot.readMessageEnd()
6479 
    result = saveEBSSettlementSummary_result()
6480 
    try:
6481 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
6482 
    except TransactionServiceException, ex:
6483 
      result.ex = ex
6484 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
6485 
    result.write(oprot)
6486 
    oprot.writeMessageEnd()
6487 
    oprot.trans.flush()
6488 
 
5189 varun.gupt 6489 
  def process_getSettlementForReferenceId(self, seqid, iprot, oprot):
6490 
    args = getSettlementForReferenceId_args()
4600 varun.gupt 6491 
    args.read(iprot)
6492 
    iprot.readMessageEnd()
5189 varun.gupt 6493 
    result = getSettlementForReferenceId_result()
4600 varun.gupt 6494 
    try:
5382 varun.gupt 6495 
      result.success = self._handler.getSettlementForReferenceId(args.referenceId, args.paymentGatewayId, args.isRefund)
4600 varun.gupt 6496 
    except TransactionServiceException, ex:
6497 
      result.ex = ex
5189 varun.gupt 6498 
    oprot.writeMessageBegin("getSettlementForReferenceId", TMessageType.REPLY, seqid)
4600 varun.gupt 6499 
    result.write(oprot)
6500 
    oprot.writeMessageEnd()
6501 
    oprot.trans.flush()
6502 
 
6503 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
6504 
    args = getEBSSettlementSummaries_args()
6505 
    args.read(iprot)
6506 
    iprot.readMessageEnd()
6507 
    result = getEBSSettlementSummaries_result()
6508 
    try:
6509 
      result.success = self._handler.getEBSSettlementSummaries()
6510 
    except TransactionServiceException, ex:
6511 
      result.ex = ex
6512 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
6513 
    result.write(oprot)
6514 
    oprot.writeMessageEnd()
6515 
    oprot.trans.flush()
6516 
 
6517 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
6518 
    args = markEBSSettlementUploaded_args()
6519 
    args.read(iprot)
6520 
    iprot.readMessageEnd()
6521 
    result = markEBSSettlementUploaded_result()
6522 
    try:
6523 
      self._handler.markEBSSettlementUploaded(args.settlementId)
6524 
    except TransactionServiceException, ex:
6525 
      result.ex = ex
6526 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
6527 
    result.write(oprot)
6528 
    oprot.writeMessageEnd()
6529 
    oprot.trans.flush()
6530 
 
6531 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
6532 
    args = getEBSSettlementDate_args()
6533 
    args.read(iprot)
6534 
    iprot.readMessageEnd()
6535 
    result = getEBSSettlementDate_result()
6536 
    try:
6537 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
6538 
    except TransactionServiceException, ex:
6539 
      result.ex = ex
6540 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
6541 
    result.write(oprot)
6542 
    oprot.writeMessageEnd()
6543 
    oprot.trans.flush()
6544 
 
4715 varun.gupt 6545 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
6546 
    args = getSettlementsByDate_args()
6547 
    args.read(iprot)
6548 
    iprot.readMessageEnd()
6549 
    result = getSettlementsByDate_result()
6550 
    try:
6551 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
6552 
    except TransactionServiceException, ex:
6553 
      result.ex = ex
6554 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
6555 
    result.write(oprot)
6556 
    oprot.writeMessageEnd()
6557 
    oprot.trans.flush()
4600 varun.gupt 6558 
 
4715 varun.gupt 6559 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
6560 
    args = getReshippedOrderIds_args()
6561 
    args.read(iprot)
6562 
    iprot.readMessageEnd()
6563 
    result = getReshippedOrderIds_result()
6564 
    try:
6565 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
6566 
    except TransactionServiceException, ex:
6567 
      result.ex = ex
6568 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
6569 
    result.write(oprot)
6570 
    oprot.writeMessageEnd()
6571 
    oprot.trans.flush()
6572 
 
5348 anupam.sin 6573 
  def process_updateOrdersAsPORaised(self, seqid, iprot, oprot):
6574 
    args = updateOrdersAsPORaised_args()
6575 
    args.read(iprot)
6576 
    iprot.readMessageEnd()
6577 
    result = updateOrdersAsPORaised_result()
6578 
    try:
6579 
      self._handler.updateOrdersAsPORaised(args.itemIdQuantityMap, args.purchaseOrderId, args.warehouseId)
6580 
    except TransactionServiceException, ex:
6581 
      result.ex = ex
6582 
    oprot.writeMessageBegin("updateOrdersAsPORaised", TMessageType.REPLY, seqid)
6583 
    result.write(oprot)
6584 
    oprot.writeMessageEnd()
6585 
    oprot.trans.flush()
6586 
 
4875 varun.gupt 6587 
  def process_getOrdersWhereVendorNotPaid(self, seqid, iprot, oprot):
6588 
    args = getOrdersWhereVendorNotPaid_args()
6589 
    args.read(iprot)
6590 
    iprot.readMessageEnd()
6591 
    result = getOrdersWhereVendorNotPaid_result()
6592 
    try:
6593 
      result.success = self._handler.getOrdersWhereVendorNotPaid(args.vendorId)
6594 
    except TransactionServiceException, ex:
6595 
      result.ex = ex
6596 
    oprot.writeMessageBegin("getOrdersWhereVendorNotPaid", TMessageType.REPLY, seqid)
6597 
    result.write(oprot)
6598 
    oprot.writeMessageEnd()
6599 
    oprot.trans.flush()
4757 mandeep.dh 6600 
 
5031 varun.gupt 6601 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
6602 
    args = getStatusDistributionOfOrders_args()
6603 
    args.read(iprot)
6604 
    iprot.readMessageEnd()
6605 
    result = getStatusDistributionOfOrders_result()
6606 
    try:
6607 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
6608 
    except TransactionServiceException, ex:
6609 
      result.ex = ex
6610 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
6611 
    result.write(oprot)
6612 
    oprot.writeMessageEnd()
6613 
    oprot.trans.flush()
4875 varun.gupt 6614 
 
5067 varun.gupt 6615 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
6616 
    args = getOrderIdsForStatus_args()
6617 
    args.read(iprot)
6618 
    iprot.readMessageEnd()
6619 
    result = getOrderIdsForStatus_result()
6620 
    try:
6621 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
6622 
    except TransactionServiceException, ex:
6623 
      result.ex = ex
6624 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
6625 
    result.write(oprot)
6626 
    oprot.writeMessageEnd()
6627 
    oprot.trans.flush()
5031 varun.gupt 6628 
 
5348 anupam.sin 6629 
  def process_updateCODAgent(self, seqid, iprot, oprot):
6630 
    args = updateCODAgent_args()
6631 
    args.read(iprot)
6632 
    iprot.readMessageEnd()
6633 
    result = updateCODAgent_result()
6634 
    try:
6635 
      self._handler.updateCODAgent(args.agent, args.orderId)
6636 
    except TransactionServiceException, ex:
6637 
      result.ex = ex
6638 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
6639 
    result.write(oprot)
6640 
    oprot.writeMessageEnd()
6641 
    oprot.trans.flush()
6642 
 
5099 varun.gupt 6643 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
6644 
    args = updateOrderAsPaidToVendor_args()
6645 
    args.read(iprot)
6646 
    iprot.readMessageEnd()
6647 
    result = updateOrderAsPaidToVendor_result()
6648 
    try:
6649 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
6650 
    except TransactionServiceException, ex:
6651 
      result.ex = ex
6652 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
6653 
    result.write(oprot)
6654 
    oprot.writeMessageEnd()
6655 
    oprot.trans.flush()
5067 varun.gupt 6656 
 
5208 varun.gupt 6657 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
6658 
    args = getRefundedOrdersMarkedPaid_args()
6659 
    args.read(iprot)
6660 
    iprot.readMessageEnd()
6661 
    result = getRefundedOrdersMarkedPaid_result()
6662 
    try:
6663 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
6664 
    except TransactionServiceException, ex:
6665 
      result.ex = ex
6666 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
6667 
    result.write(oprot)
6668 
    oprot.writeMessageEnd()
6669 
    oprot.trans.flush()
5099 varun.gupt 6670 
 
5208 varun.gupt 6671 
 
94 ashish 6672 
# HELPER FUNCTIONS AND STRUCTURES
6673 
 
6674 
class createTransaction_args:
6675 
  """
6676 
  Attributes:
6677 
   - transaction
6678 
  """
6679 
 
6680 
  thrift_spec = (
6681 
    None, # 0
6682 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
6683 
  )
6684 
 
6685 
  def __init__(self, transaction=None,):
6686 
    self.transaction = transaction
6687 
 
6688 
  def read(self, iprot):
6689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6691 
      return
6692 
    iprot.readStructBegin()
6693 
    while True:
6694 
      (fname, ftype, fid) = iprot.readFieldBegin()
6695 
      if ftype == TType.STOP:
6696 
        break
6697 
      if fid == 1:
6698 
        if ftype == TType.STRUCT:
6699 
          self.transaction = Transaction()
6700 
          self.transaction.read(iprot)
6701 
        else:
6702 
          iprot.skip(ftype)
6703 
      else:
6704 
        iprot.skip(ftype)
6705 
      iprot.readFieldEnd()
6706 
    iprot.readStructEnd()
6707 
 
6708 
  def write(self, oprot):
6709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6711 
      return
6712 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 6713 
    if self.transaction is not None:
94 ashish 6714 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
6715 
      self.transaction.write(oprot)
6716 
      oprot.writeFieldEnd()
6717 
    oprot.writeFieldStop()
6718 
    oprot.writeStructEnd()
6719 
 
3431 rajveer 6720 
  def validate(self):
6721 
    return
6722 
 
6723 
 
94 ashish 6724 
  def __repr__(self):
6725 
    L = ['%s=%r' % (key, value)
6726 
      for key, value in self.__dict__.iteritems()]
6727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6728 
 
6729 
  def __eq__(self, other):
6730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6731 
 
6732 
  def __ne__(self, other):
6733 
    return not (self == other)
6734 
 
6735 
class createTransaction_result:
6736 
  """
6737 
  Attributes:
132 ashish 6738 
   - success
94 ashish 6739 
   - ex
6740 
  """
6741 
 
6742 
  thrift_spec = (
132 ashish 6743 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 6744 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6745 
  )
6746 
 
132 ashish 6747 
  def __init__(self, success=None, ex=None,):
6748 
    self.success = success
94 ashish 6749 
    self.ex = ex
6750 
 
6751 
  def read(self, iprot):
6752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6754 
      return
6755 
    iprot.readStructBegin()
6756 
    while True:
6757 
      (fname, ftype, fid) = iprot.readFieldBegin()
6758 
      if ftype == TType.STOP:
6759 
        break
132 ashish 6760 
      if fid == 0:
6761 
        if ftype == TType.I64:
6762 
          self.success = iprot.readI64();
6763 
        else:
6764 
          iprot.skip(ftype)
6765 
      elif fid == 1:
94 ashish 6766 
        if ftype == TType.STRUCT:
6767 
          self.ex = TransactionServiceException()
6768 
          self.ex.read(iprot)
6769 
        else:
6770 
          iprot.skip(ftype)
6771 
      else:
6772 
        iprot.skip(ftype)
6773 
      iprot.readFieldEnd()
6774 
    iprot.readStructEnd()
6775 
 
6776 
  def write(self, oprot):
6777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6779 
      return
6780 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 6781 
    if self.success is not None:
132 ashish 6782 
      oprot.writeFieldBegin('success', TType.I64, 0)
6783 
      oprot.writeI64(self.success)
6784 
      oprot.writeFieldEnd()
3431 rajveer 6785 
    if self.ex is not None:
94 ashish 6786 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6787 
      self.ex.write(oprot)
6788 
      oprot.writeFieldEnd()
6789 
    oprot.writeFieldStop()
6790 
    oprot.writeStructEnd()
6791 
 
3431 rajveer 6792 
  def validate(self):
6793 
    return
6794 
 
6795 
 
94 ashish 6796 
  def __repr__(self):
6797 
    L = ['%s=%r' % (key, value)
6798 
      for key, value in self.__dict__.iteritems()]
6799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6800 
 
6801 
  def __eq__(self, other):
6802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6803 
 
6804 
  def __ne__(self, other):
6805 
    return not (self == other)
6806 
 
6807 
class getTransaction_args:
6808 
  """
6809 
  Attributes:
6810 
   - id
6811 
  """
6812 
 
6813 
  thrift_spec = (
6814 
    None, # 0
6815 
    (1, TType.I64, 'id', None, None, ), # 1
6816 
  )
6817 
 
6818 
  def __init__(self, id=None,):
6819 
    self.id = id
6820 
 
6821 
  def read(self, iprot):
6822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6824 
      return
6825 
    iprot.readStructBegin()
6826 
    while True:
6827 
      (fname, ftype, fid) = iprot.readFieldBegin()
6828 
      if ftype == TType.STOP:
6829 
        break
6830 
      if fid == 1:
6831 
        if ftype == TType.I64:
6832 
          self.id = iprot.readI64();
6833 
        else:
6834 
          iprot.skip(ftype)
6835 
      else:
6836 
        iprot.skip(ftype)
6837 
      iprot.readFieldEnd()
6838 
    iprot.readStructEnd()
6839 
 
6840 
  def write(self, oprot):
6841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6843 
      return
6844 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 6845 
    if self.id is not None:
94 ashish 6846 
      oprot.writeFieldBegin('id', TType.I64, 1)
6847 
      oprot.writeI64(self.id)
6848 
      oprot.writeFieldEnd()
6849 
    oprot.writeFieldStop()
6850 
    oprot.writeStructEnd()
6851 
 
3431 rajveer 6852 
  def validate(self):
6853 
    return
6854 
 
6855 
 
94 ashish 6856 
  def __repr__(self):
6857 
    L = ['%s=%r' % (key, value)
6858 
      for key, value in self.__dict__.iteritems()]
6859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6860 
 
6861 
  def __eq__(self, other):
6862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6863 
 
6864 
  def __ne__(self, other):
6865 
    return not (self == other)
6866 
 
6867 
class getTransaction_result:
6868 
  """
6869 
  Attributes:
6870 
   - success
6871 
   - ex
6872 
  """
6873 
 
6874 
  thrift_spec = (
6875 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
6876 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6877 
  )
6878 
 
6879 
  def __init__(self, success=None, ex=None,):
6880 
    self.success = success
6881 
    self.ex = ex
6882 
 
6883 
  def read(self, iprot):
6884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6886 
      return
6887 
    iprot.readStructBegin()
6888 
    while True:
6889 
      (fname, ftype, fid) = iprot.readFieldBegin()
6890 
      if ftype == TType.STOP:
6891 
        break
6892 
      if fid == 0:
6893 
        if ftype == TType.STRUCT:
6894 
          self.success = Transaction()
6895 
          self.success.read(iprot)
6896 
        else:
6897 
          iprot.skip(ftype)
6898 
      elif fid == 1:
6899 
        if ftype == TType.STRUCT:
6900 
          self.ex = TransactionServiceException()
6901 
          self.ex.read(iprot)
6902 
        else:
6903 
          iprot.skip(ftype)
6904 
      else:
6905 
        iprot.skip(ftype)
6906 
      iprot.readFieldEnd()
6907 
    iprot.readStructEnd()
6908 
 
6909 
  def write(self, oprot):
6910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6912 
      return
6913 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 6914 
    if self.success is not None:
94 ashish 6915 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6916 
      self.success.write(oprot)
6917 
      oprot.writeFieldEnd()
3431 rajveer 6918 
    if self.ex is not None:
94 ashish 6919 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6920 
      self.ex.write(oprot)
6921 
      oprot.writeFieldEnd()
6922 
    oprot.writeFieldStop()
6923 
    oprot.writeStructEnd()
6924 
 
3431 rajveer 6925 
  def validate(self):
6926 
    return
6927 
 
6928 
 
94 ashish 6929 
  def __repr__(self):
6930 
    L = ['%s=%r' % (key, value)
6931 
      for key, value in self.__dict__.iteritems()]
6932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6933 
 
6934 
  def __eq__(self, other):
6935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6936 
 
6937 
  def __ne__(self, other):
6938 
    return not (self == other)
6939 
 
6940 
class getTransactionsForCustomer_args:
6941 
  """
6942 
  Attributes:
6943 
   - customerId
6944 
   - from_date
6945 
   - to_date
6946 
   - status
6947 
  """
6948 
 
6949 
  thrift_spec = (
6950 
    None, # 0
6951 
    (1, TType.I64, 'customerId', None, None, ), # 1
6952 
    (2, TType.I64, 'from_date', None, None, ), # 2
6953 
    (3, TType.I64, 'to_date', None, None, ), # 3
6954 
    (4, TType.I32, 'status', None, None, ), # 4
6955 
  )
6956 
 
6957 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
6958 
    self.customerId = customerId
6959 
    self.from_date = from_date
6960 
    self.to_date = to_date
6961 
    self.status = status
6962 
 
6963 
  def read(self, iprot):
6964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6966 
      return
6967 
    iprot.readStructBegin()
6968 
    while True:
6969 
      (fname, ftype, fid) = iprot.readFieldBegin()
6970 
      if ftype == TType.STOP:
6971 
        break
6972 
      if fid == 1:
6973 
        if ftype == TType.I64:
6974 
          self.customerId = iprot.readI64();
6975 
        else:
6976 
          iprot.skip(ftype)
6977 
      elif fid == 2:
6978 
        if ftype == TType.I64:
6979 
          self.from_date = iprot.readI64();
6980 
        else:
6981 
          iprot.skip(ftype)
6982 
      elif fid == 3:
6983 
        if ftype == TType.I64:
6984 
          self.to_date = iprot.readI64();
6985 
        else:
6986 
          iprot.skip(ftype)
6987 
      elif fid == 4:
6988 
        if ftype == TType.I32:
6989 
          self.status = iprot.readI32();
6990 
        else:
6991 
          iprot.skip(ftype)
6992 
      else:
6993 
        iprot.skip(ftype)
6994 
      iprot.readFieldEnd()
6995 
    iprot.readStructEnd()
6996 
 
6997 
  def write(self, oprot):
6998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7000 
      return
7001 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 7002 
    if self.customerId is not None:
94 ashish 7003 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7004 
      oprot.writeI64(self.customerId)
7005 
      oprot.writeFieldEnd()
3431 rajveer 7006 
    if self.from_date is not None:
94 ashish 7007 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7008 
      oprot.writeI64(self.from_date)
7009 
      oprot.writeFieldEnd()
3431 rajveer 7010 
    if self.to_date is not None:
94 ashish 7011 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7012 
      oprot.writeI64(self.to_date)
7013 
      oprot.writeFieldEnd()
3431 rajveer 7014 
    if self.status is not None:
94 ashish 7015 
      oprot.writeFieldBegin('status', TType.I32, 4)
7016 
      oprot.writeI32(self.status)
7017 
      oprot.writeFieldEnd()
7018 
    oprot.writeFieldStop()
7019 
    oprot.writeStructEnd()
7020 
 
3431 rajveer 7021 
  def validate(self):
7022 
    return
7023 
 
7024 
 
94 ashish 7025 
  def __repr__(self):
7026 
    L = ['%s=%r' % (key, value)
7027 
      for key, value in self.__dict__.iteritems()]
7028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7029 
 
7030 
  def __eq__(self, other):
7031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7032 
 
7033 
  def __ne__(self, other):
7034 
    return not (self == other)
7035 
 
7036 
class getTransactionsForCustomer_result:
7037 
  """
7038 
  Attributes:
7039 
   - success
7040 
   - ex
7041 
  """
7042 
 
7043 
  thrift_spec = (
7044 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7045 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7046 
  )
7047 
 
7048 
  def __init__(self, success=None, ex=None,):
7049 
    self.success = success
7050 
    self.ex = ex
7051 
 
7052 
  def read(self, iprot):
7053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7055 
      return
7056 
    iprot.readStructBegin()
7057 
    while True:
7058 
      (fname, ftype, fid) = iprot.readFieldBegin()
7059 
      if ftype == TType.STOP:
7060 
        break
7061 
      if fid == 0:
7062 
        if ftype == TType.LIST:
7063 
          self.success = []
5031 varun.gupt 7064 
          (_etype66, _size63) = iprot.readListBegin()
7065 
          for _i67 in xrange(_size63):
7066 
            _elem68 = Transaction()
7067 
            _elem68.read(iprot)
7068 
            self.success.append(_elem68)
94 ashish 7069 
          iprot.readListEnd()
7070 
        else:
7071 
          iprot.skip(ftype)
7072 
      elif fid == 1:
7073 
        if ftype == TType.STRUCT:
7074 
          self.ex = TransactionServiceException()
7075 
          self.ex.read(iprot)
7076 
        else:
7077 
          iprot.skip(ftype)
7078 
      else:
7079 
        iprot.skip(ftype)
7080 
      iprot.readFieldEnd()
7081 
    iprot.readStructEnd()
7082 
 
7083 
  def write(self, oprot):
7084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7086 
      return
7087 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 7088 
    if self.success is not None:
94 ashish 7089 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7090 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7091 
      for iter69 in self.success:
7092 
        iter69.write(oprot)
94 ashish 7093 
      oprot.writeListEnd()
7094 
      oprot.writeFieldEnd()
3431 rajveer 7095 
    if self.ex is not None:
94 ashish 7096 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7097 
      self.ex.write(oprot)
7098 
      oprot.writeFieldEnd()
7099 
    oprot.writeFieldStop()
7100 
    oprot.writeStructEnd()
7101 
 
3431 rajveer 7102 
  def validate(self):
7103 
    return
7104 
 
7105 
 
94 ashish 7106 
  def __repr__(self):
7107 
    L = ['%s=%r' % (key, value)
7108 
      for key, value in self.__dict__.iteritems()]
7109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7110 
 
7111 
  def __eq__(self, other):
7112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7113 
 
7114 
  def __ne__(self, other):
7115 
    return not (self == other)
7116 
 
132 ashish 7117 
class getTransactionsForShoppingCartId_args:
7118 
  """
7119 
  Attributes:
7120 
   - shoppingCartId
7121 
  """
7122 
 
7123 
  thrift_spec = (
7124 
    None, # 0
7125 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
7126 
  )
7127 
 
7128 
  def __init__(self, shoppingCartId=None,):
7129 
    self.shoppingCartId = shoppingCartId
7130 
 
7131 
  def read(self, iprot):
7132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7134 
      return
7135 
    iprot.readStructBegin()
7136 
    while True:
7137 
      (fname, ftype, fid) = iprot.readFieldBegin()
7138 
      if ftype == TType.STOP:
7139 
        break
7140 
      if fid == 1:
7141 
        if ftype == TType.I64:
7142 
          self.shoppingCartId = iprot.readI64();
7143 
        else:
7144 
          iprot.skip(ftype)
7145 
      else:
7146 
        iprot.skip(ftype)
7147 
      iprot.readFieldEnd()
7148 
    iprot.readStructEnd()
7149 
 
7150 
  def write(self, oprot):
7151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7153 
      return
7154 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 7155 
    if self.shoppingCartId is not None:
132 ashish 7156 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
7157 
      oprot.writeI64(self.shoppingCartId)
7158 
      oprot.writeFieldEnd()
7159 
    oprot.writeFieldStop()
7160 
    oprot.writeStructEnd()
7161 
 
3431 rajveer 7162 
  def validate(self):
7163 
    return
7164 
 
7165 
 
132 ashish 7166 
  def __repr__(self):
7167 
    L = ['%s=%r' % (key, value)
7168 
      for key, value in self.__dict__.iteritems()]
7169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7170 
 
7171 
  def __eq__(self, other):
7172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7173 
 
7174 
  def __ne__(self, other):
7175 
    return not (self == other)
7176 
 
7177 
class getTransactionsForShoppingCartId_result:
7178 
  """
7179 
  Attributes:
7180 
   - success
7181 
   - ex
7182 
  """
7183 
 
7184 
  thrift_spec = (
7185 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7186 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7187 
  )
7188 
 
7189 
  def __init__(self, success=None, ex=None,):
7190 
    self.success = success
7191 
    self.ex = ex
7192 
 
7193 
  def read(self, iprot):
7194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7196 
      return
7197 
    iprot.readStructBegin()
7198 
    while True:
7199 
      (fname, ftype, fid) = iprot.readFieldBegin()
7200 
      if ftype == TType.STOP:
7201 
        break
7202 
      if fid == 0:
7203 
        if ftype == TType.LIST:
7204 
          self.success = []
5031 varun.gupt 7205 
          (_etype73, _size70) = iprot.readListBegin()
7206 
          for _i74 in xrange(_size70):
7207 
            _elem75 = Transaction()
7208 
            _elem75.read(iprot)
7209 
            self.success.append(_elem75)
132 ashish 7210 
          iprot.readListEnd()
7211 
        else:
7212 
          iprot.skip(ftype)
7213 
      elif fid == 1:
7214 
        if ftype == TType.STRUCT:
7215 
          self.ex = TransactionServiceException()
7216 
          self.ex.read(iprot)
7217 
        else:
7218 
          iprot.skip(ftype)
7219 
      else:
7220 
        iprot.skip(ftype)
7221 
      iprot.readFieldEnd()
7222 
    iprot.readStructEnd()
7223 
 
7224 
  def write(self, oprot):
7225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7227 
      return
7228 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 7229 
    if self.success is not None:
132 ashish 7230 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7231 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7232 
      for iter76 in self.success:
7233 
        iter76.write(oprot)
132 ashish 7234 
      oprot.writeListEnd()
7235 
      oprot.writeFieldEnd()
3431 rajveer 7236 
    if self.ex is not None:
132 ashish 7237 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7238 
      self.ex.write(oprot)
7239 
      oprot.writeFieldEnd()
7240 
    oprot.writeFieldStop()
7241 
    oprot.writeStructEnd()
7242 
 
3431 rajveer 7243 
  def validate(self):
7244 
    return
7245 
 
7246 
 
132 ashish 7247 
  def __repr__(self):
7248 
    L = ['%s=%r' % (key, value)
7249 
      for key, value in self.__dict__.iteritems()]
7250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7251 
 
7252 
  def __eq__(self, other):
7253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7254 
 
7255 
  def __ne__(self, other):
7256 
    return not (self == other)
7257 
 
94 ashish 7258 
class getTransactionStatus_args:
7259 
  """
7260 
  Attributes:
7261 
   - transactionId
7262 
  """
7263 
 
7264 
  thrift_spec = (
7265 
    None, # 0
7266 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7267 
  )
7268 
 
7269 
  def __init__(self, transactionId=None,):
7270 
    self.transactionId = transactionId
7271 
 
7272 
  def read(self, iprot):
7273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7275 
      return
7276 
    iprot.readStructBegin()
7277 
    while True:
7278 
      (fname, ftype, fid) = iprot.readFieldBegin()
7279 
      if ftype == TType.STOP:
7280 
        break
7281 
      if fid == 1:
7282 
        if ftype == TType.I64:
7283 
          self.transactionId = iprot.readI64();
7284 
        else:
7285 
          iprot.skip(ftype)
7286 
      else:
7287 
        iprot.skip(ftype)
7288 
      iprot.readFieldEnd()
7289 
    iprot.readStructEnd()
7290 
 
7291 
  def write(self, oprot):
7292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7294 
      return
7295 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 7296 
    if self.transactionId is not None:
94 ashish 7297 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7298 
      oprot.writeI64(self.transactionId)
7299 
      oprot.writeFieldEnd()
7300 
    oprot.writeFieldStop()
7301 
    oprot.writeStructEnd()
7302 
 
3431 rajveer 7303 
  def validate(self):
7304 
    return
7305 
 
7306 
 
94 ashish 7307 
  def __repr__(self):
7308 
    L = ['%s=%r' % (key, value)
7309 
      for key, value in self.__dict__.iteritems()]
7310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7311 
 
7312 
  def __eq__(self, other):
7313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7314 
 
7315 
  def __ne__(self, other):
7316 
    return not (self == other)
7317 
 
7318 
class getTransactionStatus_result:
7319 
  """
7320 
  Attributes:
7321 
   - success
7322 
   - ex
7323 
  """
7324 
 
7325 
  thrift_spec = (
7326 
    (0, TType.I32, 'success', None, None, ), # 0
7327 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7328 
  )
7329 
 
7330 
  def __init__(self, success=None, ex=None,):
7331 
    self.success = success
7332 
    self.ex = ex
7333 
 
7334 
  def read(self, iprot):
7335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7337 
      return
7338 
    iprot.readStructBegin()
7339 
    while True:
7340 
      (fname, ftype, fid) = iprot.readFieldBegin()
7341 
      if ftype == TType.STOP:
7342 
        break
7343 
      if fid == 0:
7344 
        if ftype == TType.I32:
7345 
          self.success = iprot.readI32();
7346 
        else:
7347 
          iprot.skip(ftype)
7348 
      elif fid == 1:
7349 
        if ftype == TType.STRUCT:
7350 
          self.ex = TransactionServiceException()
7351 
          self.ex.read(iprot)
7352 
        else:
7353 
          iprot.skip(ftype)
7354 
      else:
7355 
        iprot.skip(ftype)
7356 
      iprot.readFieldEnd()
7357 
    iprot.readStructEnd()
7358 
 
7359 
  def write(self, oprot):
7360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7362 
      return
7363 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 7364 
    if self.success is not None:
94 ashish 7365 
      oprot.writeFieldBegin('success', TType.I32, 0)
7366 
      oprot.writeI32(self.success)
7367 
      oprot.writeFieldEnd()
3431 rajveer 7368 
    if self.ex is not None:
94 ashish 7369 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7370 
      self.ex.write(oprot)
7371 
      oprot.writeFieldEnd()
7372 
    oprot.writeFieldStop()
7373 
    oprot.writeStructEnd()
7374 
 
3431 rajveer 7375 
  def validate(self):
7376 
    return
7377 
 
7378 
 
94 ashish 7379 
  def __repr__(self):
7380 
    L = ['%s=%r' % (key, value)
7381 
      for key, value in self.__dict__.iteritems()]
7382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7383 
 
7384 
  def __eq__(self, other):
7385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7386 
 
7387 
  def __ne__(self, other):
7388 
    return not (self == other)
7389 
 
7390 
class changeTransactionStatus_args:
7391 
  """
7392 
  Attributes:
7393 
   - transactionId
7394 
   - status
7395 
   - description
7396 
  """
7397 
 
7398 
  thrift_spec = (
7399 
    None, # 0
7400 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7401 
    (2, TType.I32, 'status', None, None, ), # 2
7402 
    (3, TType.STRING, 'description', None, None, ), # 3
7403 
  )
7404 
 
7405 
  def __init__(self, transactionId=None, status=None, description=None,):
7406 
    self.transactionId = transactionId
7407 
    self.status = status
7408 
    self.description = description
7409 
 
7410 
  def read(self, iprot):
7411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7413 
      return
7414 
    iprot.readStructBegin()
7415 
    while True:
7416 
      (fname, ftype, fid) = iprot.readFieldBegin()
7417 
      if ftype == TType.STOP:
7418 
        break
7419 
      if fid == 1:
7420 
        if ftype == TType.I64:
7421 
          self.transactionId = iprot.readI64();
7422 
        else:
7423 
          iprot.skip(ftype)
7424 
      elif fid == 2:
7425 
        if ftype == TType.I32:
7426 
          self.status = iprot.readI32();
7427 
        else:
7428 
          iprot.skip(ftype)
7429 
      elif fid == 3:
7430 
        if ftype == TType.STRING:
7431 
          self.description = iprot.readString();
7432 
        else:
7433 
          iprot.skip(ftype)
7434 
      else:
7435 
        iprot.skip(ftype)
7436 
      iprot.readFieldEnd()
7437 
    iprot.readStructEnd()
7438 
 
7439 
  def write(self, oprot):
7440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7442 
      return
7443 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 7444 
    if self.transactionId is not None:
94 ashish 7445 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7446 
      oprot.writeI64(self.transactionId)
7447 
      oprot.writeFieldEnd()
3431 rajveer 7448 
    if self.status is not None:
94 ashish 7449 
      oprot.writeFieldBegin('status', TType.I32, 2)
7450 
      oprot.writeI32(self.status)
7451 
      oprot.writeFieldEnd()
3431 rajveer 7452 
    if self.description is not None:
94 ashish 7453 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7454 
      oprot.writeString(self.description)
7455 
      oprot.writeFieldEnd()
7456 
    oprot.writeFieldStop()
7457 
    oprot.writeStructEnd()
7458 
 
3431 rajveer 7459 
  def validate(self):
7460 
    return
7461 
 
7462 
 
94 ashish 7463 
  def __repr__(self):
7464 
    L = ['%s=%r' % (key, value)
7465 
      for key, value in self.__dict__.iteritems()]
7466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7467 
 
7468 
  def __eq__(self, other):
7469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7470 
 
7471 
  def __ne__(self, other):
7472 
    return not (self == other)
7473 
 
7474 
class changeTransactionStatus_result:
7475 
  """
7476 
  Attributes:
7477 
   - success
7478 
   - ex
7479 
  """
7480 
 
7481 
  thrift_spec = (
7482 
    (0, TType.BOOL, 'success', None, None, ), # 0
7483 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7484 
  )
7485 
 
7486 
  def __init__(self, success=None, ex=None,):
7487 
    self.success = success
7488 
    self.ex = ex
7489 
 
7490 
  def read(self, iprot):
7491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7493 
      return
7494 
    iprot.readStructBegin()
7495 
    while True:
7496 
      (fname, ftype, fid) = iprot.readFieldBegin()
7497 
      if ftype == TType.STOP:
7498 
        break
7499 
      if fid == 0:
7500 
        if ftype == TType.BOOL:
7501 
          self.success = iprot.readBool();
7502 
        else:
7503 
          iprot.skip(ftype)
7504 
      elif fid == 1:
7505 
        if ftype == TType.STRUCT:
7506 
          self.ex = TransactionServiceException()
7507 
          self.ex.read(iprot)
7508 
        else:
7509 
          iprot.skip(ftype)
7510 
      else:
7511 
        iprot.skip(ftype)
7512 
      iprot.readFieldEnd()
7513 
    iprot.readStructEnd()
7514 
 
7515 
  def write(self, oprot):
7516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7518 
      return
7519 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 7520 
    if self.success is not None:
94 ashish 7521 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7522 
      oprot.writeBool(self.success)
7523 
      oprot.writeFieldEnd()
3431 rajveer 7524 
    if self.ex is not None:
94 ashish 7525 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7526 
      self.ex.write(oprot)
7527 
      oprot.writeFieldEnd()
7528 
    oprot.writeFieldStop()
7529 
    oprot.writeStructEnd()
7530 
 
3431 rajveer 7531 
  def validate(self):
7532 
    return
7533 
 
7534 
 
94 ashish 7535 
  def __repr__(self):
7536 
    L = ['%s=%r' % (key, value)
7537 
      for key, value in self.__dict__.iteritems()]
7538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7539 
 
7540 
  def __eq__(self, other):
7541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7542 
 
7543 
  def __ne__(self, other):
7544 
    return not (self == other)
7545 
 
1398 varun.gupt 7546 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 7547 
  """
7548 
  Attributes:
7549 
   - transactionId
7550 
  """
7551 
 
7552 
  thrift_spec = (
7553 
    None, # 0
7554 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7555 
  )
7556 
 
7557 
  def __init__(self, transactionId=None,):
7558 
    self.transactionId = transactionId
7559 
 
7560 
  def read(self, iprot):
7561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7563 
      return
7564 
    iprot.readStructBegin()
7565 
    while True:
7566 
      (fname, ftype, fid) = iprot.readFieldBegin()
7567 
      if ftype == TType.STOP:
7568 
        break
7569 
      if fid == 1:
7570 
        if ftype == TType.I64:
7571 
          self.transactionId = iprot.readI64();
7572 
        else:
7573 
          iprot.skip(ftype)
7574 
      else:
7575 
        iprot.skip(ftype)
7576 
      iprot.readFieldEnd()
7577 
    iprot.readStructEnd()
7578 
 
7579 
  def write(self, oprot):
7580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7582 
      return
1398 varun.gupt 7583 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 7584 
    if self.transactionId is not None:
1382 varun.gupt 7585 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7586 
      oprot.writeI64(self.transactionId)
7587 
      oprot.writeFieldEnd()
7588 
    oprot.writeFieldStop()
7589 
    oprot.writeStructEnd()
7590 
 
3431 rajveer 7591 
  def validate(self):
7592 
    return
7593 
 
7594 
 
1382 varun.gupt 7595 
  def __repr__(self):
7596 
    L = ['%s=%r' % (key, value)
7597 
      for key, value in self.__dict__.iteritems()]
7598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7599 
 
7600 
  def __eq__(self, other):
7601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7602 
 
7603 
  def __ne__(self, other):
7604 
    return not (self == other)
7605 
 
1398 varun.gupt 7606 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 7607 
  """
7608 
  Attributes:
7609 
   - success
7610 
   - ex
7611 
  """
7612 
 
7613 
  thrift_spec = (
7614 
    (0, TType.BOOL, 'success', None, None, ), # 0
7615 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7616 
  )
7617 
 
7618 
  def __init__(self, success=None, ex=None,):
7619 
    self.success = success
7620 
    self.ex = ex
7621 
 
7622 
  def read(self, iprot):
7623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7625 
      return
7626 
    iprot.readStructBegin()
7627 
    while True:
7628 
      (fname, ftype, fid) = iprot.readFieldBegin()
7629 
      if ftype == TType.STOP:
7630 
        break
7631 
      if fid == 0:
7632 
        if ftype == TType.BOOL:
7633 
          self.success = iprot.readBool();
7634 
        else:
7635 
          iprot.skip(ftype)
7636 
      elif fid == 1:
7637 
        if ftype == TType.STRUCT:
7638 
          self.ex = TransactionServiceException()
7639 
          self.ex.read(iprot)
7640 
        else:
7641 
          iprot.skip(ftype)
7642 
      else:
7643 
        iprot.skip(ftype)
7644 
      iprot.readFieldEnd()
7645 
    iprot.readStructEnd()
7646 
 
7647 
  def write(self, oprot):
7648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7650 
      return
1398 varun.gupt 7651 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 7652 
    if self.success is not None:
1382 varun.gupt 7653 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7654 
      oprot.writeBool(self.success)
7655 
      oprot.writeFieldEnd()
3431 rajveer 7656 
    if self.ex is not None:
1382 varun.gupt 7657 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7658 
      self.ex.write(oprot)
7659 
      oprot.writeFieldEnd()
7660 
    oprot.writeFieldStop()
7661 
    oprot.writeStructEnd()
7662 
 
3431 rajveer 7663 
  def validate(self):
7664 
    return
7665 
 
7666 
 
1382 varun.gupt 7667 
  def __repr__(self):
7668 
    L = ['%s=%r' % (key, value)
7669 
      for key, value in self.__dict__.iteritems()]
7670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7671 
 
7672 
  def __eq__(self, other):
7673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7674 
 
7675 
  def __ne__(self, other):
7676 
    return not (self == other)
7677 
 
483 rajveer 7678 
class getAllOrders_args:
94 ashish 7679 
  """
7680 
  Attributes:
4801 anupam.sin 7681 
   - statuses
483 rajveer 7682 
   - from_date
7683 
   - to_date
7684 
   - warehouse_id
94 ashish 7685 
  """
7686 
 
7687 
  thrift_spec = (
7688 
    None, # 0
4801 anupam.sin 7689 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 7690 
    (2, TType.I64, 'from_date', None, None, ), # 2
7691 
    (3, TType.I64, 'to_date', None, None, ), # 3
7692 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 7693 
  )
7694 
 
4801 anupam.sin 7695 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
7696 
    self.statuses = statuses
483 rajveer 7697 
    self.from_date = from_date
7698 
    self.to_date = to_date
7699 
    self.warehouse_id = warehouse_id
94 ashish 7700 
 
7701 
  def read(self, iprot):
7702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7704 
      return
7705 
    iprot.readStructBegin()
7706 
    while True:
7707 
      (fname, ftype, fid) = iprot.readFieldBegin()
7708 
      if ftype == TType.STOP:
7709 
        break
7710 
      if fid == 1:
4801 anupam.sin 7711 
        if ftype == TType.LIST:
7712 
          self.statuses = []
5031 varun.gupt 7713 
          (_etype80, _size77) = iprot.readListBegin()
7714 
          for _i81 in xrange(_size77):
7715 
            _elem82 = iprot.readI32();
7716 
            self.statuses.append(_elem82)
4801 anupam.sin 7717 
          iprot.readListEnd()
94 ashish 7718 
        else:
7719 
          iprot.skip(ftype)
483 rajveer 7720 
      elif fid == 2:
7721 
        if ftype == TType.I64:
7722 
          self.from_date = iprot.readI64();
94 ashish 7723 
        else:
7724 
          iprot.skip(ftype)
483 rajveer 7725 
      elif fid == 3:
7726 
        if ftype == TType.I64:
7727 
          self.to_date = iprot.readI64();
94 ashish 7728 
        else:
7729 
          iprot.skip(ftype)
483 rajveer 7730 
      elif fid == 4:
94 ashish 7731 
        if ftype == TType.I64:
483 rajveer 7732 
          self.warehouse_id = iprot.readI64();
94 ashish 7733 
        else:
7734 
          iprot.skip(ftype)
7735 
      else:
7736 
        iprot.skip(ftype)
7737 
      iprot.readFieldEnd()
7738 
    iprot.readStructEnd()
7739 
 
7740 
  def write(self, oprot):
7741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7743 
      return
483 rajveer 7744 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 7745 
    if self.statuses is not None:
7746 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7747 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7748 
      for iter83 in self.statuses:
7749 
        oprot.writeI32(iter83)
4801 anupam.sin 7750 
      oprot.writeListEnd()
94 ashish 7751 
      oprot.writeFieldEnd()
3431 rajveer 7752 
    if self.from_date is not None:
483 rajveer 7753 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7754 
      oprot.writeI64(self.from_date)
94 ashish 7755 
      oprot.writeFieldEnd()
3431 rajveer 7756 
    if self.to_date is not None:
483 rajveer 7757 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7758 
      oprot.writeI64(self.to_date)
94 ashish 7759 
      oprot.writeFieldEnd()
3431 rajveer 7760 
    if self.warehouse_id is not None:
483 rajveer 7761 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7762 
      oprot.writeI64(self.warehouse_id)
94 ashish 7763 
      oprot.writeFieldEnd()
7764 
    oprot.writeFieldStop()
7765 
    oprot.writeStructEnd()
7766 
 
3431 rajveer 7767 
  def validate(self):
7768 
    return
7769 
 
7770 
 
94 ashish 7771 
  def __repr__(self):
7772 
    L = ['%s=%r' % (key, value)
7773 
      for key, value in self.__dict__.iteritems()]
7774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7775 
 
7776 
  def __eq__(self, other):
7777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7778 
 
7779 
  def __ne__(self, other):
7780 
    return not (self == other)
7781 
 
483 rajveer 7782 
class getAllOrders_result:
94 ashish 7783 
  """
7784 
  Attributes:
7785 
   - success
7786 
   - ex
7787 
  """
7788 
 
7789 
  thrift_spec = (
483 rajveer 7790 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 7791 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7792 
  )
7793 
 
7794 
  def __init__(self, success=None, ex=None,):
7795 
    self.success = success
7796 
    self.ex = ex
7797 
 
7798 
  def read(self, iprot):
7799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7801 
      return
7802 
    iprot.readStructBegin()
7803 
    while True:
7804 
      (fname, ftype, fid) = iprot.readFieldBegin()
7805 
      if ftype == TType.STOP:
7806 
        break
7807 
      if fid == 0:
483 rajveer 7808 
        if ftype == TType.LIST:
7809 
          self.success = []
5031 varun.gupt 7810 
          (_etype87, _size84) = iprot.readListBegin()
7811 
          for _i88 in xrange(_size84):
7812 
            _elem89 = Order()
7813 
            _elem89.read(iprot)
7814 
            self.success.append(_elem89)
483 rajveer 7815 
          iprot.readListEnd()
94 ashish 7816 
        else:
7817 
          iprot.skip(ftype)
7818 
      elif fid == 1:
7819 
        if ftype == TType.STRUCT:
7820 
          self.ex = TransactionServiceException()
7821 
          self.ex.read(iprot)
7822 
        else:
7823 
          iprot.skip(ftype)
7824 
      else:
7825 
        iprot.skip(ftype)
7826 
      iprot.readFieldEnd()
7827 
    iprot.readStructEnd()
7828 
 
7829 
  def write(self, oprot):
7830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7832 
      return
483 rajveer 7833 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 7834 
    if self.success is not None:
483 rajveer 7835 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7836 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7837 
      for iter90 in self.success:
7838 
        iter90.write(oprot)
483 rajveer 7839 
      oprot.writeListEnd()
94 ashish 7840 
      oprot.writeFieldEnd()
3431 rajveer 7841 
    if self.ex is not None:
94 ashish 7842 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7843 
      self.ex.write(oprot)
7844 
      oprot.writeFieldEnd()
7845 
    oprot.writeFieldStop()
7846 
    oprot.writeStructEnd()
7847 
 
3431 rajveer 7848 
  def validate(self):
7849 
    return
7850 
 
7851 
 
94 ashish 7852 
  def __repr__(self):
7853 
    L = ['%s=%r' % (key, value)
7854 
      for key, value in self.__dict__.iteritems()]
7855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7856 
 
7857 
  def __eq__(self, other):
7858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7859 
 
7860 
  def __ne__(self, other):
7861 
    return not (self == other)
7862 
 
4133 chandransh 7863 
class getOrdersInBatch_args:
7864 
  """
7865 
  Attributes:
7866 
   - statuses
7867 
   - offset
7868 
   - limit
7869 
   - warehouse_id
7870 
  """
7871 
 
7872 
  thrift_spec = (
7873 
    None, # 0
7874 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7875 
    (2, TType.I64, 'offset', None, None, ), # 2
7876 
    (3, TType.I64, 'limit', None, None, ), # 3
7877 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7878 
  )
7879 
 
7880 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
7881 
    self.statuses = statuses
7882 
    self.offset = offset
7883 
    self.limit = limit
7884 
    self.warehouse_id = warehouse_id
7885 
 
7886 
  def read(self, iprot):
7887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7889 
      return
7890 
    iprot.readStructBegin()
7891 
    while True:
7892 
      (fname, ftype, fid) = iprot.readFieldBegin()
7893 
      if ftype == TType.STOP:
7894 
        break
7895 
      if fid == 1:
7896 
        if ftype == TType.LIST:
7897 
          self.statuses = []
5031 varun.gupt 7898 
          (_etype94, _size91) = iprot.readListBegin()
7899 
          for _i95 in xrange(_size91):
7900 
            _elem96 = iprot.readI32();
7901 
            self.statuses.append(_elem96)
4133 chandransh 7902 
          iprot.readListEnd()
7903 
        else:
7904 
          iprot.skip(ftype)
7905 
      elif fid == 2:
7906 
        if ftype == TType.I64:
7907 
          self.offset = iprot.readI64();
7908 
        else:
7909 
          iprot.skip(ftype)
7910 
      elif fid == 3:
7911 
        if ftype == TType.I64:
7912 
          self.limit = iprot.readI64();
7913 
        else:
7914 
          iprot.skip(ftype)
7915 
      elif fid == 4:
7916 
        if ftype == TType.I64:
7917 
          self.warehouse_id = iprot.readI64();
7918 
        else:
7919 
          iprot.skip(ftype)
7920 
      else:
7921 
        iprot.skip(ftype)
7922 
      iprot.readFieldEnd()
7923 
    iprot.readStructEnd()
7924 
 
7925 
  def write(self, oprot):
7926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7928 
      return
7929 
    oprot.writeStructBegin('getOrdersInBatch_args')
7930 
    if self.statuses is not None:
7931 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7932 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7933 
      for iter97 in self.statuses:
7934 
        oprot.writeI32(iter97)
4133 chandransh 7935 
      oprot.writeListEnd()
7936 
      oprot.writeFieldEnd()
7937 
    if self.offset is not None:
7938 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7939 
      oprot.writeI64(self.offset)
7940 
      oprot.writeFieldEnd()
7941 
    if self.limit is not None:
7942 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7943 
      oprot.writeI64(self.limit)
7944 
      oprot.writeFieldEnd()
7945 
    if self.warehouse_id is not None:
7946 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7947 
      oprot.writeI64(self.warehouse_id)
7948 
      oprot.writeFieldEnd()
7949 
    oprot.writeFieldStop()
7950 
    oprot.writeStructEnd()
7951 
 
7952 
  def validate(self):
7953 
    return
7954 
 
7955 
 
7956 
  def __repr__(self):
7957 
    L = ['%s=%r' % (key, value)
7958 
      for key, value in self.__dict__.iteritems()]
7959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7960 
 
7961 
  def __eq__(self, other):
7962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7963 
 
7964 
  def __ne__(self, other):
7965 
    return not (self == other)
7966 
 
7967 
class getOrdersInBatch_result:
7968 
  """
7969 
  Attributes:
7970 
   - success
7971 
   - ex
7972 
  """
7973 
 
7974 
  thrift_spec = (
7975 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7976 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7977 
  )
7978 
 
7979 
  def __init__(self, success=None, ex=None,):
7980 
    self.success = success
7981 
    self.ex = ex
7982 
 
7983 
  def read(self, iprot):
7984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7986 
      return
7987 
    iprot.readStructBegin()
7988 
    while True:
7989 
      (fname, ftype, fid) = iprot.readFieldBegin()
7990 
      if ftype == TType.STOP:
7991 
        break
7992 
      if fid == 0:
7993 
        if ftype == TType.LIST:
7994 
          self.success = []
5031 varun.gupt 7995 
          (_etype101, _size98) = iprot.readListBegin()
7996 
          for _i102 in xrange(_size98):
7997 
            _elem103 = Order()
7998 
            _elem103.read(iprot)
7999 
            self.success.append(_elem103)
4133 chandransh 8000 
          iprot.readListEnd()
8001 
        else:
8002 
          iprot.skip(ftype)
8003 
      elif fid == 1:
8004 
        if ftype == TType.STRUCT:
8005 
          self.ex = TransactionServiceException()
8006 
          self.ex.read(iprot)
8007 
        else:
8008 
          iprot.skip(ftype)
8009 
      else:
8010 
        iprot.skip(ftype)
8011 
      iprot.readFieldEnd()
8012 
    iprot.readStructEnd()
8013 
 
8014 
  def write(self, oprot):
8015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8017 
      return
8018 
    oprot.writeStructBegin('getOrdersInBatch_result')
8019 
    if self.success is not None:
8020 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8021 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8022 
      for iter104 in self.success:
8023 
        iter104.write(oprot)
4133 chandransh 8024 
      oprot.writeListEnd()
8025 
      oprot.writeFieldEnd()
8026 
    if self.ex is not None:
8027 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8028 
      self.ex.write(oprot)
8029 
      oprot.writeFieldEnd()
8030 
    oprot.writeFieldStop()
8031 
    oprot.writeStructEnd()
8032 
 
8033 
  def validate(self):
8034 
    return
8035 
 
8036 
 
8037 
  def __repr__(self):
8038 
    L = ['%s=%r' % (key, value)
8039 
      for key, value in self.__dict__.iteritems()]
8040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8041 
 
8042 
  def __eq__(self, other):
8043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8044 
 
8045 
  def __ne__(self, other):
8046 
    return not (self == other)
8047 
 
8048 
class getOrderCount_args:
8049 
  """
8050 
  Attributes:
8051 
   - statuses
8052 
   - warehouseId
8053 
  """
8054 
 
8055 
  thrift_spec = (
8056 
    None, # 0
8057 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8058 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8059 
  )
8060 
 
8061 
  def __init__(self, statuses=None, warehouseId=None,):
8062 
    self.statuses = statuses
8063 
    self.warehouseId = warehouseId
8064 
 
8065 
  def read(self, iprot):
8066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8068 
      return
8069 
    iprot.readStructBegin()
8070 
    while True:
8071 
      (fname, ftype, fid) = iprot.readFieldBegin()
8072 
      if ftype == TType.STOP:
8073 
        break
8074 
      if fid == 1:
8075 
        if ftype == TType.LIST:
8076 
          self.statuses = []
5031 varun.gupt 8077 
          (_etype108, _size105) = iprot.readListBegin()
8078 
          for _i109 in xrange(_size105):
8079 
            _elem110 = iprot.readI32();
8080 
            self.statuses.append(_elem110)
4133 chandransh 8081 
          iprot.readListEnd()
8082 
        else:
8083 
          iprot.skip(ftype)
8084 
      elif fid == 2:
8085 
        if ftype == TType.I64:
8086 
          self.warehouseId = iprot.readI64();
8087 
        else:
8088 
          iprot.skip(ftype)
8089 
      else:
8090 
        iprot.skip(ftype)
8091 
      iprot.readFieldEnd()
8092 
    iprot.readStructEnd()
8093 
 
8094 
  def write(self, oprot):
8095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8097 
      return
8098 
    oprot.writeStructBegin('getOrderCount_args')
8099 
    if self.statuses is not None:
8100 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8101 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8102 
      for iter111 in self.statuses:
8103 
        oprot.writeI32(iter111)
4133 chandransh 8104 
      oprot.writeListEnd()
8105 
      oprot.writeFieldEnd()
8106 
    if self.warehouseId is not None:
8107 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8108 
      oprot.writeI64(self.warehouseId)
8109 
      oprot.writeFieldEnd()
8110 
    oprot.writeFieldStop()
8111 
    oprot.writeStructEnd()
8112 
 
8113 
  def validate(self):
8114 
    return
8115 
 
8116 
 
8117 
  def __repr__(self):
8118 
    L = ['%s=%r' % (key, value)
8119 
      for key, value in self.__dict__.iteritems()]
8120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8121 
 
8122 
  def __eq__(self, other):
8123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8124 
 
8125 
  def __ne__(self, other):
8126 
    return not (self == other)
8127 
 
8128 
class getOrderCount_result:
8129 
  """
8130 
  Attributes:
8131 
   - success
8132 
   - ex
8133 
  """
8134 
 
8135 
  thrift_spec = (
8136 
    (0, TType.I32, 'success', None, None, ), # 0
8137 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8138 
  )
8139 
 
8140 
  def __init__(self, success=None, ex=None,):
8141 
    self.success = success
8142 
    self.ex = ex
8143 
 
8144 
  def read(self, iprot):
8145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8147 
      return
8148 
    iprot.readStructBegin()
8149 
    while True:
8150 
      (fname, ftype, fid) = iprot.readFieldBegin()
8151 
      if ftype == TType.STOP:
8152 
        break
8153 
      if fid == 0:
8154 
        if ftype == TType.I32:
8155 
          self.success = iprot.readI32();
8156 
        else:
8157 
          iprot.skip(ftype)
8158 
      elif fid == 1:
8159 
        if ftype == TType.STRUCT:
8160 
          self.ex = TransactionServiceException()
8161 
          self.ex.read(iprot)
8162 
        else:
8163 
          iprot.skip(ftype)
8164 
      else:
8165 
        iprot.skip(ftype)
8166 
      iprot.readFieldEnd()
8167 
    iprot.readStructEnd()
8168 
 
8169 
  def write(self, oprot):
8170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8172 
      return
8173 
    oprot.writeStructBegin('getOrderCount_result')
8174 
    if self.success is not None:
8175 
      oprot.writeFieldBegin('success', TType.I32, 0)
8176 
      oprot.writeI32(self.success)
8177 
      oprot.writeFieldEnd()
8178 
    if self.ex is not None:
8179 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8180 
      self.ex.write(oprot)
8181 
      oprot.writeFieldEnd()
8182 
    oprot.writeFieldStop()
8183 
    oprot.writeStructEnd()
8184 
 
8185 
  def validate(self):
8186 
    return
8187 
 
8188 
 
8189 
  def __repr__(self):
8190 
    L = ['%s=%r' % (key, value)
8191 
      for key, value in self.__dict__.iteritems()]
8192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8193 
 
8194 
  def __eq__(self, other):
8195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8196 
 
8197 
  def __ne__(self, other):
8198 
    return not (self == other)
8199 
 
999 varun.gupt 8200 
class getOrdersByBillingDate_args:
8201 
  """
8202 
  Attributes:
8203 
   - status
8204 
   - start_billing_date
8205 
   - end_billing_date
8206 
   - warehouse_id
8207 
  """
8208 
 
8209 
  thrift_spec = (
8210 
    None, # 0
8211 
    (1, TType.I32, 'status', None, None, ), # 1
8212 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
8213 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
8214 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8215 
  )
8216 
 
8217 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
8218 
    self.status = status
8219 
    self.start_billing_date = start_billing_date
8220 
    self.end_billing_date = end_billing_date
8221 
    self.warehouse_id = warehouse_id
8222 
 
8223 
  def read(self, iprot):
8224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8226 
      return
8227 
    iprot.readStructBegin()
8228 
    while True:
8229 
      (fname, ftype, fid) = iprot.readFieldBegin()
8230 
      if ftype == TType.STOP:
8231 
        break
8232 
      if fid == 1:
8233 
        if ftype == TType.I32:
8234 
          self.status = iprot.readI32();
8235 
        else:
8236 
          iprot.skip(ftype)
8237 
      elif fid == 2:
8238 
        if ftype == TType.I64:
8239 
          self.start_billing_date = iprot.readI64();
8240 
        else:
8241 
          iprot.skip(ftype)
8242 
      elif fid == 3:
8243 
        if ftype == TType.I64:
8244 
          self.end_billing_date = iprot.readI64();
8245 
        else:
8246 
          iprot.skip(ftype)
8247 
      elif fid == 4:
8248 
        if ftype == TType.I64:
8249 
          self.warehouse_id = iprot.readI64();
8250 
        else:
8251 
          iprot.skip(ftype)
8252 
      else:
8253 
        iprot.skip(ftype)
8254 
      iprot.readFieldEnd()
8255 
    iprot.readStructEnd()
8256 
 
8257 
  def write(self, oprot):
8258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8260 
      return
8261 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 8262 
    if self.status is not None:
999 varun.gupt 8263 
      oprot.writeFieldBegin('status', TType.I32, 1)
8264 
      oprot.writeI32(self.status)
8265 
      oprot.writeFieldEnd()
3431 rajveer 8266 
    if self.start_billing_date is not None:
999 varun.gupt 8267 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
8268 
      oprot.writeI64(self.start_billing_date)
8269 
      oprot.writeFieldEnd()
3431 rajveer 8270 
    if self.end_billing_date is not None:
999 varun.gupt 8271 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
8272 
      oprot.writeI64(self.end_billing_date)
8273 
      oprot.writeFieldEnd()
3431 rajveer 8274 
    if self.warehouse_id is not None:
999 varun.gupt 8275 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8276 
      oprot.writeI64(self.warehouse_id)
8277 
      oprot.writeFieldEnd()
8278 
    oprot.writeFieldStop()
8279 
    oprot.writeStructEnd()
8280 
 
3431 rajveer 8281 
  def validate(self):
8282 
    return
8283 
 
8284 
 
999 varun.gupt 8285 
  def __repr__(self):
8286 
    L = ['%s=%r' % (key, value)
8287 
      for key, value in self.__dict__.iteritems()]
8288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8289 
 
8290 
  def __eq__(self, other):
8291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8292 
 
8293 
  def __ne__(self, other):
8294 
    return not (self == other)
8295 
 
8296 
class getOrdersByBillingDate_result:
8297 
  """
8298 
  Attributes:
8299 
   - success
8300 
   - ex
8301 
  """
8302 
 
8303 
  thrift_spec = (
8304 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8305 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8306 
  )
8307 
 
8308 
  def __init__(self, success=None, ex=None,):
8309 
    self.success = success
8310 
    self.ex = ex
8311 
 
8312 
  def read(self, iprot):
8313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8315 
      return
8316 
    iprot.readStructBegin()
8317 
    while True:
8318 
      (fname, ftype, fid) = iprot.readFieldBegin()
8319 
      if ftype == TType.STOP:
8320 
        break
8321 
      if fid == 0:
8322 
        if ftype == TType.LIST:
8323 
          self.success = []
5031 varun.gupt 8324 
          (_etype115, _size112) = iprot.readListBegin()
8325 
          for _i116 in xrange(_size112):
8326 
            _elem117 = Order()
8327 
            _elem117.read(iprot)
8328 
            self.success.append(_elem117)
999 varun.gupt 8329 
          iprot.readListEnd()
8330 
        else:
8331 
          iprot.skip(ftype)
8332 
      elif fid == 1:
8333 
        if ftype == TType.STRUCT:
8334 
          self.ex = TransactionServiceException()
8335 
          self.ex.read(iprot)
8336 
        else:
8337 
          iprot.skip(ftype)
8338 
      else:
8339 
        iprot.skip(ftype)
8340 
      iprot.readFieldEnd()
8341 
    iprot.readStructEnd()
8342 
 
8343 
  def write(self, oprot):
8344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8346 
      return
8347 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 8348 
    if self.success is not None:
999 varun.gupt 8349 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8350 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8351 
      for iter118 in self.success:
8352 
        iter118.write(oprot)
999 varun.gupt 8353 
      oprot.writeListEnd()
8354 
      oprot.writeFieldEnd()
3431 rajveer 8355 
    if self.ex is not None:
999 varun.gupt 8356 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8357 
      self.ex.write(oprot)
8358 
      oprot.writeFieldEnd()
8359 
    oprot.writeFieldStop()
8360 
    oprot.writeStructEnd()
8361 
 
3431 rajveer 8362 
  def validate(self):
8363 
    return
8364 
 
8365 
 
999 varun.gupt 8366 
  def __repr__(self):
8367 
    L = ['%s=%r' % (key, value)
8368 
      for key, value in self.__dict__.iteritems()]
8369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8370 
 
8371 
  def __eq__(self, other):
8372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8373 
 
8374 
  def __ne__(self, other):
8375 
    return not (self == other)
8376 
 
3427 chandransh 8377 
class getOrdersByShippingDate_args:
8378 
  """
8379 
  Attributes:
8380 
   - fromShippingDate
8381 
   - toShippingDate
8382 
   - providerId
8383 
   - warehouseId
3451 chandransh 8384 
   - cod
3427 chandransh 8385 
  """
8386 
 
8387 
  thrift_spec = (
8388 
    None, # 0
8389 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
8390 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
8391 
    (3, TType.I64, 'providerId', None, None, ), # 3
8392 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 8393 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 8394 
  )
8395 
 
3451 chandransh 8396 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 8397 
    self.fromShippingDate = fromShippingDate
8398 
    self.toShippingDate = toShippingDate
8399 
    self.providerId = providerId
8400 
    self.warehouseId = warehouseId
3451 chandransh 8401 
    self.cod = cod
3427 chandransh 8402 
 
8403 
  def read(self, iprot):
8404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8406 
      return
8407 
    iprot.readStructBegin()
8408 
    while True:
8409 
      (fname, ftype, fid) = iprot.readFieldBegin()
8410 
      if ftype == TType.STOP:
8411 
        break
8412 
      if fid == 1:
8413 
        if ftype == TType.I64:
8414 
          self.fromShippingDate = iprot.readI64();
8415 
        else:
8416 
          iprot.skip(ftype)
8417 
      elif fid == 2:
8418 
        if ftype == TType.I64:
8419 
          self.toShippingDate = iprot.readI64();
8420 
        else:
8421 
          iprot.skip(ftype)
8422 
      elif fid == 3:
8423 
        if ftype == TType.I64:
8424 
          self.providerId = iprot.readI64();
8425 
        else:
8426 
          iprot.skip(ftype)
8427 
      elif fid == 4:
8428 
        if ftype == TType.I64:
8429 
          self.warehouseId = iprot.readI64();
8430 
        else:
8431 
          iprot.skip(ftype)
3451 chandransh 8432 
      elif fid == 5:
8433 
        if ftype == TType.BOOL:
8434 
          self.cod = iprot.readBool();
8435 
        else:
8436 
          iprot.skip(ftype)
3427 chandransh 8437 
      else:
8438 
        iprot.skip(ftype)
8439 
      iprot.readFieldEnd()
8440 
    iprot.readStructEnd()
8441 
 
8442 
  def write(self, oprot):
8443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8445 
      return
8446 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 8447 
    if self.fromShippingDate is not None:
3427 chandransh 8448 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
8449 
      oprot.writeI64(self.fromShippingDate)
8450 
      oprot.writeFieldEnd()
3431 rajveer 8451 
    if self.toShippingDate is not None:
3427 chandransh 8452 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
8453 
      oprot.writeI64(self.toShippingDate)
8454 
      oprot.writeFieldEnd()
3431 rajveer 8455 
    if self.providerId is not None:
3427 chandransh 8456 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
8457 
      oprot.writeI64(self.providerId)
8458 
      oprot.writeFieldEnd()
3431 rajveer 8459 
    if self.warehouseId is not None:
3427 chandransh 8460 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
8461 
      oprot.writeI64(self.warehouseId)
8462 
      oprot.writeFieldEnd()
3451 chandransh 8463 
    if self.cod is not None:
8464 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
8465 
      oprot.writeBool(self.cod)
8466 
      oprot.writeFieldEnd()
3427 chandransh 8467 
    oprot.writeFieldStop()
8468 
    oprot.writeStructEnd()
8469 
 
3431 rajveer 8470 
  def validate(self):
8471 
    return
8472 
 
8473 
 
3427 chandransh 8474 
  def __repr__(self):
8475 
    L = ['%s=%r' % (key, value)
8476 
      for key, value in self.__dict__.iteritems()]
8477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8478 
 
8479 
  def __eq__(self, other):
8480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8481 
 
8482 
  def __ne__(self, other):
8483 
    return not (self == other)
8484 
 
8485 
class getOrdersByShippingDate_result:
8486 
  """
8487 
  Attributes:
8488 
   - success
8489 
   - ex
8490 
  """
8491 
 
8492 
  thrift_spec = (
8493 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8494 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8495 
  )
8496 
 
8497 
  def __init__(self, success=None, ex=None,):
8498 
    self.success = success
8499 
    self.ex = ex
8500 
 
8501 
  def read(self, iprot):
8502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8504 
      return
8505 
    iprot.readStructBegin()
8506 
    while True:
8507 
      (fname, ftype, fid) = iprot.readFieldBegin()
8508 
      if ftype == TType.STOP:
8509 
        break
8510 
      if fid == 0:
8511 
        if ftype == TType.LIST:
8512 
          self.success = []
5031 varun.gupt 8513 
          (_etype122, _size119) = iprot.readListBegin()
8514 
          for _i123 in xrange(_size119):
8515 
            _elem124 = Order()
8516 
            _elem124.read(iprot)
8517 
            self.success.append(_elem124)
3427 chandransh 8518 
          iprot.readListEnd()
8519 
        else:
8520 
          iprot.skip(ftype)
8521 
      elif fid == 1:
8522 
        if ftype == TType.STRUCT:
8523 
          self.ex = TransactionServiceException()
8524 
          self.ex.read(iprot)
8525 
        else:
8526 
          iprot.skip(ftype)
8527 
      else:
8528 
        iprot.skip(ftype)
8529 
      iprot.readFieldEnd()
8530 
    iprot.readStructEnd()
8531 
 
8532 
  def write(self, oprot):
8533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8535 
      return
8536 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 8537 
    if self.success is not None:
3427 chandransh 8538 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8539 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8540 
      for iter125 in self.success:
8541 
        iter125.write(oprot)
3427 chandransh 8542 
      oprot.writeListEnd()
8543 
      oprot.writeFieldEnd()
3431 rajveer 8544 
    if self.ex is not None:
3427 chandransh 8545 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8546 
      self.ex.write(oprot)
8547 
      oprot.writeFieldEnd()
8548 
    oprot.writeFieldStop()
8549 
    oprot.writeStructEnd()
8550 
 
3431 rajveer 8551 
  def validate(self):
8552 
    return
8553 
 
8554 
 
3427 chandransh 8555 
  def __repr__(self):
8556 
    L = ['%s=%r' % (key, value)
8557 
      for key, value in self.__dict__.iteritems()]
8558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8559 
 
8560 
  def __eq__(self, other):
8561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8562 
 
8563 
  def __ne__(self, other):
8564 
    return not (self == other)
8565 
 
1382 varun.gupt 8566 
class getReturnableOrdersForCustomer_args:
8567 
  """
8568 
  Attributes:
8569 
   - customer_id
8570 
   - limit
8571 
  """
8572 
 
8573 
  thrift_spec = (
8574 
    None, # 0
8575 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8576 
    (2, TType.I64, 'limit', None, None, ), # 2
8577 
  )
8578 
 
8579 
  def __init__(self, customer_id=None, limit=None,):
8580 
    self.customer_id = customer_id
8581 
    self.limit = limit
8582 
 
8583 
  def read(self, iprot):
8584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8586 
      return
8587 
    iprot.readStructBegin()
8588 
    while True:
8589 
      (fname, ftype, fid) = iprot.readFieldBegin()
8590 
      if ftype == TType.STOP:
8591 
        break
8592 
      if fid == 1:
8593 
        if ftype == TType.I64:
8594 
          self.customer_id = iprot.readI64();
8595 
        else:
8596 
          iprot.skip(ftype)
8597 
      elif fid == 2:
8598 
        if ftype == TType.I64:
8599 
          self.limit = iprot.readI64();
8600 
        else:
8601 
          iprot.skip(ftype)
8602 
      else:
8603 
        iprot.skip(ftype)
8604 
      iprot.readFieldEnd()
8605 
    iprot.readStructEnd()
8606 
 
8607 
  def write(self, oprot):
8608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8610 
      return
8611 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 8612 
    if self.customer_id is not None:
1382 varun.gupt 8613 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8614 
      oprot.writeI64(self.customer_id)
8615 
      oprot.writeFieldEnd()
3431 rajveer 8616 
    if self.limit is not None:
1382 varun.gupt 8617 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8618 
      oprot.writeI64(self.limit)
8619 
      oprot.writeFieldEnd()
8620 
    oprot.writeFieldStop()
8621 
    oprot.writeStructEnd()
8622 
 
3431 rajveer 8623 
  def validate(self):
8624 
    return
8625 
 
8626 
 
1382 varun.gupt 8627 
  def __repr__(self):
8628 
    L = ['%s=%r' % (key, value)
8629 
      for key, value in self.__dict__.iteritems()]
8630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8631 
 
8632 
  def __eq__(self, other):
8633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8634 
 
8635 
  def __ne__(self, other):
8636 
    return not (self == other)
8637 
 
8638 
class getReturnableOrdersForCustomer_result:
8639 
  """
8640 
  Attributes:
8641 
   - success
8642 
   - ex
8643 
  """
8644 
 
8645 
  thrift_spec = (
8646 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8647 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8648 
  )
8649 
 
8650 
  def __init__(self, success=None, ex=None,):
8651 
    self.success = success
8652 
    self.ex = ex
8653 
 
8654 
  def read(self, iprot):
8655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8657 
      return
8658 
    iprot.readStructBegin()
8659 
    while True:
8660 
      (fname, ftype, fid) = iprot.readFieldBegin()
8661 
      if ftype == TType.STOP:
8662 
        break
8663 
      if fid == 0:
8664 
        if ftype == TType.LIST:
8665 
          self.success = []
5031 varun.gupt 8666 
          (_etype129, _size126) = iprot.readListBegin()
8667 
          for _i130 in xrange(_size126):
8668 
            _elem131 = iprot.readI64();
8669 
            self.success.append(_elem131)
1382 varun.gupt 8670 
          iprot.readListEnd()
8671 
        else:
8672 
          iprot.skip(ftype)
8673 
      elif fid == 1:
8674 
        if ftype == TType.STRUCT:
8675 
          self.ex = TransactionServiceException()
8676 
          self.ex.read(iprot)
8677 
        else:
8678 
          iprot.skip(ftype)
8679 
      else:
8680 
        iprot.skip(ftype)
8681 
      iprot.readFieldEnd()
8682 
    iprot.readStructEnd()
8683 
 
8684 
  def write(self, oprot):
8685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8687 
      return
8688 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 8689 
    if self.success is not None:
1382 varun.gupt 8690 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8691 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8692 
      for iter132 in self.success:
8693 
        oprot.writeI64(iter132)
1382 varun.gupt 8694 
      oprot.writeListEnd()
8695 
      oprot.writeFieldEnd()
3431 rajveer 8696 
    if self.ex is not None:
1382 varun.gupt 8697 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8698 
      self.ex.write(oprot)
8699 
      oprot.writeFieldEnd()
8700 
    oprot.writeFieldStop()
8701 
    oprot.writeStructEnd()
8702 
 
3431 rajveer 8703 
  def validate(self):
8704 
    return
8705 
 
8706 
 
1382 varun.gupt 8707 
  def __repr__(self):
8708 
    L = ['%s=%r' % (key, value)
8709 
      for key, value in self.__dict__.iteritems()]
8710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8711 
 
8712 
  def __eq__(self, other):
8713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8714 
 
8715 
  def __ne__(self, other):
8716 
    return not (self == other)
8717 
 
8718 
class getCancellableOrdersForCustomer_args:
8719 
  """
8720 
  Attributes:
8721 
   - customer_id
8722 
   - limit
8723 
  """
8724 
 
8725 
  thrift_spec = (
8726 
    None, # 0
8727 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8728 
    (2, TType.I64, 'limit', None, None, ), # 2
8729 
  )
8730 
 
8731 
  def __init__(self, customer_id=None, limit=None,):
8732 
    self.customer_id = customer_id
8733 
    self.limit = limit
8734 
 
8735 
  def read(self, iprot):
8736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8738 
      return
8739 
    iprot.readStructBegin()
8740 
    while True:
8741 
      (fname, ftype, fid) = iprot.readFieldBegin()
8742 
      if ftype == TType.STOP:
8743 
        break
8744 
      if fid == 1:
8745 
        if ftype == TType.I64:
8746 
          self.customer_id = iprot.readI64();
8747 
        else:
8748 
          iprot.skip(ftype)
8749 
      elif fid == 2:
8750 
        if ftype == TType.I64:
8751 
          self.limit = iprot.readI64();
8752 
        else:
8753 
          iprot.skip(ftype)
8754 
      else:
8755 
        iprot.skip(ftype)
8756 
      iprot.readFieldEnd()
8757 
    iprot.readStructEnd()
8758 
 
8759 
  def write(self, oprot):
8760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8762 
      return
8763 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 8764 
    if self.customer_id is not None:
1382 varun.gupt 8765 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8766 
      oprot.writeI64(self.customer_id)
8767 
      oprot.writeFieldEnd()
3431 rajveer 8768 
    if self.limit is not None:
1382 varun.gupt 8769 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8770 
      oprot.writeI64(self.limit)
8771 
      oprot.writeFieldEnd()
8772 
    oprot.writeFieldStop()
8773 
    oprot.writeStructEnd()
8774 
 
3431 rajveer 8775 
  def validate(self):
8776 
    return
8777 
 
8778 
 
1382 varun.gupt 8779 
  def __repr__(self):
8780 
    L = ['%s=%r' % (key, value)
8781 
      for key, value in self.__dict__.iteritems()]
8782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8783 
 
8784 
  def __eq__(self, other):
8785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8786 
 
8787 
  def __ne__(self, other):
8788 
    return not (self == other)
8789 
 
8790 
class getCancellableOrdersForCustomer_result:
8791 
  """
8792 
  Attributes:
8793 
   - success
8794 
   - ex
8795 
  """
8796 
 
8797 
  thrift_spec = (
8798 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8799 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8800 
  )
8801 
 
8802 
  def __init__(self, success=None, ex=None,):
8803 
    self.success = success
8804 
    self.ex = ex
8805 
 
8806 
  def read(self, iprot):
8807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8809 
      return
8810 
    iprot.readStructBegin()
8811 
    while True:
8812 
      (fname, ftype, fid) = iprot.readFieldBegin()
8813 
      if ftype == TType.STOP:
8814 
        break
8815 
      if fid == 0:
8816 
        if ftype == TType.LIST:
8817 
          self.success = []
5031 varun.gupt 8818 
          (_etype136, _size133) = iprot.readListBegin()
8819 
          for _i137 in xrange(_size133):
8820 
            _elem138 = iprot.readI64();
8821 
            self.success.append(_elem138)
1382 varun.gupt 8822 
          iprot.readListEnd()
8823 
        else:
8824 
          iprot.skip(ftype)
8825 
      elif fid == 1:
8826 
        if ftype == TType.STRUCT:
8827 
          self.ex = TransactionServiceException()
8828 
          self.ex.read(iprot)
8829 
        else:
8830 
          iprot.skip(ftype)
8831 
      else:
8832 
        iprot.skip(ftype)
8833 
      iprot.readFieldEnd()
8834 
    iprot.readStructEnd()
8835 
 
8836 
  def write(self, oprot):
8837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8839 
      return
8840 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 8841 
    if self.success is not None:
1382 varun.gupt 8842 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8843 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8844 
      for iter139 in self.success:
8845 
        oprot.writeI64(iter139)
1382 varun.gupt 8846 
      oprot.writeListEnd()
8847 
      oprot.writeFieldEnd()
3431 rajveer 8848 
    if self.ex is not None:
1382 varun.gupt 8849 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8850 
      self.ex.write(oprot)
8851 
      oprot.writeFieldEnd()
8852 
    oprot.writeFieldStop()
8853 
    oprot.writeStructEnd()
8854 
 
3431 rajveer 8855 
  def validate(self):
8856 
    return
8857 
 
8858 
 
1382 varun.gupt 8859 
  def __repr__(self):
8860 
    L = ['%s=%r' % (key, value)
8861 
      for key, value in self.__dict__.iteritems()]
8862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8863 
 
8864 
  def __eq__(self, other):
8865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8866 
 
8867 
  def __ne__(self, other):
8868 
    return not (self == other)
8869 
 
483 rajveer 8870 
class changeOrderStatus_args:
94 ashish 8871 
  """
8872 
  Attributes:
483 rajveer 8873 
   - orderId
8874 
   - status
8875 
   - description
94 ashish 8876 
  """
8877 
 
8878 
  thrift_spec = (
8879 
    None, # 0
483 rajveer 8880 
    (1, TType.I64, 'orderId', None, None, ), # 1
8881 
    (2, TType.I32, 'status', None, None, ), # 2
8882 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8883 
  )
8884 
 
483 rajveer 8885 
  def __init__(self, orderId=None, status=None, description=None,):
8886 
    self.orderId = orderId
8887 
    self.status = status
8888 
    self.description = description
94 ashish 8889 
 
8890 
  def read(self, iprot):
8891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8893 
      return
8894 
    iprot.readStructBegin()
8895 
    while True:
8896 
      (fname, ftype, fid) = iprot.readFieldBegin()
8897 
      if ftype == TType.STOP:
8898 
        break
8899 
      if fid == 1:
8900 
        if ftype == TType.I64:
483 rajveer 8901 
          self.orderId = iprot.readI64();
94 ashish 8902 
        else:
8903 
          iprot.skip(ftype)
8904 
      elif fid == 2:
483 rajveer 8905 
        if ftype == TType.I32:
8906 
          self.status = iprot.readI32();
94 ashish 8907 
        else:
8908 
          iprot.skip(ftype)
483 rajveer 8909 
      elif fid == 3:
8910 
        if ftype == TType.STRING:
8911 
          self.description = iprot.readString();
8912 
        else:
8913 
          iprot.skip(ftype)
94 ashish 8914 
      else:
8915 
        iprot.skip(ftype)
8916 
      iprot.readFieldEnd()
8917 
    iprot.readStructEnd()
8918 
 
8919 
  def write(self, oprot):
8920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8922 
      return
483 rajveer 8923 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 8924 
    if self.orderId is not None:
483 rajveer 8925 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8926 
      oprot.writeI64(self.orderId)
94 ashish 8927 
      oprot.writeFieldEnd()
3431 rajveer 8928 
    if self.status is not None:
483 rajveer 8929 
      oprot.writeFieldBegin('status', TType.I32, 2)
8930 
      oprot.writeI32(self.status)
94 ashish 8931 
      oprot.writeFieldEnd()
3431 rajveer 8932 
    if self.description is not None:
483 rajveer 8933 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8934 
      oprot.writeString(self.description)
8935 
      oprot.writeFieldEnd()
94 ashish 8936 
    oprot.writeFieldStop()
8937 
    oprot.writeStructEnd()
8938 
 
3431 rajveer 8939 
  def validate(self):
8940 
    return
8941 
 
8942 
 
94 ashish 8943 
  def __repr__(self):
8944 
    L = ['%s=%r' % (key, value)
8945 
      for key, value in self.__dict__.iteritems()]
8946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8947 
 
8948 
  def __eq__(self, other):
8949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8950 
 
8951 
  def __ne__(self, other):
8952 
    return not (self == other)
8953 
 
483 rajveer 8954 
class changeOrderStatus_result:
94 ashish 8955 
  """
8956 
  Attributes:
8957 
   - success
8958 
   - ex
8959 
  """
8960 
 
8961 
  thrift_spec = (
8962 
    (0, TType.BOOL, 'success', None, None, ), # 0
8963 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8964 
  )
8965 
 
8966 
  def __init__(self, success=None, ex=None,):
8967 
    self.success = success
8968 
    self.ex = ex
8969 
 
8970 
  def read(self, iprot):
8971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8973 
      return
8974 
    iprot.readStructBegin()
8975 
    while True:
8976 
      (fname, ftype, fid) = iprot.readFieldBegin()
8977 
      if ftype == TType.STOP:
8978 
        break
8979 
      if fid == 0:
8980 
        if ftype == TType.BOOL:
8981 
          self.success = iprot.readBool();
8982 
        else:
8983 
          iprot.skip(ftype)
8984 
      elif fid == 1:
8985 
        if ftype == TType.STRUCT:
8986 
          self.ex = TransactionServiceException()
8987 
          self.ex.read(iprot)
8988 
        else:
8989 
          iprot.skip(ftype)
8990 
      else:
8991 
        iprot.skip(ftype)
8992 
      iprot.readFieldEnd()
8993 
    iprot.readStructEnd()
8994 
 
8995 
  def write(self, oprot):
8996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8998 
      return
483 rajveer 8999 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 9000 
    if self.success is not None:
94 ashish 9001 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9002 
      oprot.writeBool(self.success)
9003 
      oprot.writeFieldEnd()
3431 rajveer 9004 
    if self.ex is not None:
94 ashish 9005 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9006 
      self.ex.write(oprot)
9007 
      oprot.writeFieldEnd()
9008 
    oprot.writeFieldStop()
9009 
    oprot.writeStructEnd()
9010 
 
3431 rajveer 9011 
  def validate(self):
9012 
    return
9013 
 
9014 
 
94 ashish 9015 
  def __repr__(self):
9016 
    L = ['%s=%r' % (key, value)
9017 
      for key, value in self.__dict__.iteritems()]
9018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9019 
 
9020 
  def __eq__(self, other):
9021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9022 
 
9023 
  def __ne__(self, other):
9024 
    return not (self == other)
9025 
 
3064 chandransh 9026 
class getOrdersForTransaction_args:
494 rajveer 9027 
  """
9028 
  Attributes:
3064 chandransh 9029 
   - transactionId
9030 
   - customerId
494 rajveer 9031 
  """
9032 
 
9033 
  thrift_spec = (
9034 
    None, # 0
3064 chandransh 9035 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9036 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 9037 
  )
9038 
 
3064 chandransh 9039 
  def __init__(self, transactionId=None, customerId=None,):
9040 
    self.transactionId = transactionId
9041 
    self.customerId = customerId
494 rajveer 9042 
 
9043 
  def read(self, iprot):
9044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9046 
      return
9047 
    iprot.readStructBegin()
9048 
    while True:
9049 
      (fname, ftype, fid) = iprot.readFieldBegin()
9050 
      if ftype == TType.STOP:
9051 
        break
9052 
      if fid == 1:
9053 
        if ftype == TType.I64:
3064 chandransh 9054 
          self.transactionId = iprot.readI64();
494 rajveer 9055 
        else:
9056 
          iprot.skip(ftype)
9057 
      elif fid == 2:
3064 chandransh 9058 
        if ftype == TType.I64:
9059 
          self.customerId = iprot.readI64();
494 rajveer 9060 
        else:
9061 
          iprot.skip(ftype)
9062 
      else:
9063 
        iprot.skip(ftype)
9064 
      iprot.readFieldEnd()
9065 
    iprot.readStructEnd()
9066 
 
9067 
  def write(self, oprot):
9068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9070 
      return
3064 chandransh 9071 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 9072 
    if self.transactionId is not None:
3064 chandransh 9073 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9074 
      oprot.writeI64(self.transactionId)
494 rajveer 9075 
      oprot.writeFieldEnd()
3431 rajveer 9076 
    if self.customerId is not None:
3064 chandransh 9077 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
9078 
      oprot.writeI64(self.customerId)
494 rajveer 9079 
      oprot.writeFieldEnd()
9080 
    oprot.writeFieldStop()
9081 
    oprot.writeStructEnd()
9082 
 
3431 rajveer 9083 
  def validate(self):
9084 
    return
9085 
 
9086 
 
494 rajveer 9087 
  def __repr__(self):
9088 
    L = ['%s=%r' % (key, value)
9089 
      for key, value in self.__dict__.iteritems()]
9090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9091 
 
9092 
  def __eq__(self, other):
9093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9094 
 
9095 
  def __ne__(self, other):
9096 
    return not (self == other)
9097 
 
3064 chandransh 9098 
class getOrdersForTransaction_result:
494 rajveer 9099 
  """
9100 
  Attributes:
9101 
   - success
9102 
   - ex
9103 
  """
9104 
 
9105 
  thrift_spec = (
3064 chandransh 9106 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 9107 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9108 
  )
9109 
 
9110 
  def __init__(self, success=None, ex=None,):
9111 
    self.success = success
9112 
    self.ex = ex
9113 
 
9114 
  def read(self, iprot):
9115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9117 
      return
9118 
    iprot.readStructBegin()
9119 
    while True:
9120 
      (fname, ftype, fid) = iprot.readFieldBegin()
9121 
      if ftype == TType.STOP:
9122 
        break
9123 
      if fid == 0:
3064 chandransh 9124 
        if ftype == TType.LIST:
9125 
          self.success = []
5031 varun.gupt 9126 
          (_etype143, _size140) = iprot.readListBegin()
9127 
          for _i144 in xrange(_size140):
9128 
            _elem145 = Order()
9129 
            _elem145.read(iprot)
9130 
            self.success.append(_elem145)
3064 chandransh 9131 
          iprot.readListEnd()
494 rajveer 9132 
        else:
9133 
          iprot.skip(ftype)
9134 
      elif fid == 1:
9135 
        if ftype == TType.STRUCT:
9136 
          self.ex = TransactionServiceException()
9137 
          self.ex.read(iprot)
9138 
        else:
9139 
          iprot.skip(ftype)
9140 
      else:
9141 
        iprot.skip(ftype)
9142 
      iprot.readFieldEnd()
9143 
    iprot.readStructEnd()
9144 
 
9145 
  def write(self, oprot):
9146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9148 
      return
3064 chandransh 9149 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 9150 
    if self.success is not None:
3064 chandransh 9151 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9152 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9153 
      for iter146 in self.success:
9154 
        iter146.write(oprot)
3064 chandransh 9155 
      oprot.writeListEnd()
494 rajveer 9156 
      oprot.writeFieldEnd()
3431 rajveer 9157 
    if self.ex is not None:
494 rajveer 9158 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9159 
      self.ex.write(oprot)
9160 
      oprot.writeFieldEnd()
9161 
    oprot.writeFieldStop()
9162 
    oprot.writeStructEnd()
9163 
 
3431 rajveer 9164 
  def validate(self):
9165 
    return
9166 
 
9167 
 
494 rajveer 9168 
  def __repr__(self):
9169 
    L = ['%s=%r' % (key, value)
9170 
      for key, value in self.__dict__.iteritems()]
9171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9172 
 
9173 
  def __eq__(self, other):
9174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9175 
 
9176 
  def __ne__(self, other):
9177 
    return not (self == other)
9178 
 
3064 chandransh 9179 
class getOrdersForCustomer_args:
1149 chandransh 9180 
  """
9181 
  Attributes:
3064 chandransh 9182 
   - customerId
9183 
   - from_date
9184 
   - to_date
9185 
   - statuses
1149 chandransh 9186 
  """
9187 
 
9188 
  thrift_spec = (
9189 
    None, # 0
3064 chandransh 9190 
    (1, TType.I64, 'customerId', None, None, ), # 1
9191 
    (2, TType.I64, 'from_date', None, None, ), # 2
9192 
    (3, TType.I64, 'to_date', None, None, ), # 3
9193 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 9194 
  )
9195 
 
3064 chandransh 9196 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
9197 
    self.customerId = customerId
9198 
    self.from_date = from_date
9199 
    self.to_date = to_date
9200 
    self.statuses = statuses
1149 chandransh 9201 
 
9202 
  def read(self, iprot):
9203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9205 
      return
9206 
    iprot.readStructBegin()
9207 
    while True:
9208 
      (fname, ftype, fid) = iprot.readFieldBegin()
9209 
      if ftype == TType.STOP:
9210 
        break
9211 
      if fid == 1:
9212 
        if ftype == TType.I64:
3064 chandransh 9213 
          self.customerId = iprot.readI64();
1149 chandransh 9214 
        else:
9215 
          iprot.skip(ftype)
9216 
      elif fid == 2:
9217 
        if ftype == TType.I64:
3064 chandransh 9218 
          self.from_date = iprot.readI64();
1149 chandransh 9219 
        else:
9220 
          iprot.skip(ftype)
2783 chandransh 9221 
      elif fid == 3:
9222 
        if ftype == TType.I64:
3064 chandransh 9223 
          self.to_date = iprot.readI64();
2783 chandransh 9224 
        else:
9225 
          iprot.skip(ftype)
9226 
      elif fid == 4:
3064 chandransh 9227 
        if ftype == TType.LIST:
9228 
          self.statuses = []
5031 varun.gupt 9229 
          (_etype150, _size147) = iprot.readListBegin()
9230 
          for _i151 in xrange(_size147):
9231 
            _elem152 = iprot.readI32();
9232 
            self.statuses.append(_elem152)
3064 chandransh 9233 
          iprot.readListEnd()
2783 chandransh 9234 
        else:
9235 
          iprot.skip(ftype)
1149 chandransh 9236 
      else:
9237 
        iprot.skip(ftype)
9238 
      iprot.readFieldEnd()
9239 
    iprot.readStructEnd()
9240 
 
9241 
  def write(self, oprot):
9242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9244 
      return
3064 chandransh 9245 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 9246 
    if self.customerId is not None:
3064 chandransh 9247 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9248 
      oprot.writeI64(self.customerId)
1149 chandransh 9249 
      oprot.writeFieldEnd()
3431 rajveer 9250 
    if self.from_date is not None:
3064 chandransh 9251 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9252 
      oprot.writeI64(self.from_date)
1149 chandransh 9253 
      oprot.writeFieldEnd()
3431 rajveer 9254 
    if self.to_date is not None:
3064 chandransh 9255 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9256 
      oprot.writeI64(self.to_date)
2783 chandransh 9257 
      oprot.writeFieldEnd()
3431 rajveer 9258 
    if self.statuses is not None:
3064 chandransh 9259 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
9260 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 9261 
      for iter153 in self.statuses:
9262 
        oprot.writeI32(iter153)
3064 chandransh 9263 
      oprot.writeListEnd()
2783 chandransh 9264 
      oprot.writeFieldEnd()
1149 chandransh 9265 
    oprot.writeFieldStop()
9266 
    oprot.writeStructEnd()
9267 
 
3431 rajveer 9268 
  def validate(self):
9269 
    return
9270 
 
9271 
 
1149 chandransh 9272 
  def __repr__(self):
9273 
    L = ['%s=%r' % (key, value)
9274 
      for key, value in self.__dict__.iteritems()]
9275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9276 
 
9277 
  def __eq__(self, other):
9278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9279 
 
9280 
  def __ne__(self, other):
9281 
    return not (self == other)
9282 
 
3064 chandransh 9283 
class getOrdersForCustomer_result:
1149 chandransh 9284 
  """
9285 
  Attributes:
9286 
   - success
9287 
   - ex
9288 
  """
9289 
 
9290 
  thrift_spec = (
3064 chandransh 9291 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 9292 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9293 
  )
9294 
 
9295 
  def __init__(self, success=None, ex=None,):
9296 
    self.success = success
9297 
    self.ex = ex
9298 
 
9299 
  def read(self, iprot):
9300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9302 
      return
9303 
    iprot.readStructBegin()
9304 
    while True:
9305 
      (fname, ftype, fid) = iprot.readFieldBegin()
9306 
      if ftype == TType.STOP:
9307 
        break
9308 
      if fid == 0:
3064 chandransh 9309 
        if ftype == TType.LIST:
9310 
          self.success = []
5031 varun.gupt 9311 
          (_etype157, _size154) = iprot.readListBegin()
9312 
          for _i158 in xrange(_size154):
9313 
            _elem159 = Order()
9314 
            _elem159.read(iprot)
9315 
            self.success.append(_elem159)
3064 chandransh 9316 
          iprot.readListEnd()
1149 chandransh 9317 
        else:
9318 
          iprot.skip(ftype)
9319 
      elif fid == 1:
9320 
        if ftype == TType.STRUCT:
9321 
          self.ex = TransactionServiceException()
9322 
          self.ex.read(iprot)
9323 
        else:
9324 
          iprot.skip(ftype)
9325 
      else:
9326 
        iprot.skip(ftype)
9327 
      iprot.readFieldEnd()
9328 
    iprot.readStructEnd()
9329 
 
9330 
  def write(self, oprot):
9331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9333 
      return
3064 chandransh 9334 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 9335 
    if self.success is not None:
3064 chandransh 9336 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9337 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9338 
      for iter160 in self.success:
9339 
        iter160.write(oprot)
3064 chandransh 9340 
      oprot.writeListEnd()
1149 chandransh 9341 
      oprot.writeFieldEnd()
3431 rajveer 9342 
    if self.ex is not None:
1149 chandransh 9343 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9344 
      self.ex.write(oprot)
9345 
      oprot.writeFieldEnd()
9346 
    oprot.writeFieldStop()
9347 
    oprot.writeStructEnd()
9348 
 
3431 rajveer 9349 
  def validate(self):
9350 
    return
9351 
 
9352 
 
1149 chandransh 9353 
  def __repr__(self):
9354 
    L = ['%s=%r' % (key, value)
9355 
      for key, value in self.__dict__.iteritems()]
9356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9357 
 
9358 
  def __eq__(self, other):
9359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9360 
 
9361 
  def __ne__(self, other):
9362 
    return not (self == other)
9363 
 
3064 chandransh 9364 
class createOrder_args:
921 rajveer 9365 
  """
9366 
  Attributes:
3064 chandransh 9367 
   - order
921 rajveer 9368 
  """
9369 
 
9370 
  thrift_spec = (
9371 
    None, # 0
3064 chandransh 9372 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 9373 
  )
9374 
 
3064 chandransh 9375 
  def __init__(self, order=None,):
9376 
    self.order = order
921 rajveer 9377 
 
9378 
  def read(self, iprot):
9379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9381 
      return
9382 
    iprot.readStructBegin()
9383 
    while True:
9384 
      (fname, ftype, fid) = iprot.readFieldBegin()
9385 
      if ftype == TType.STOP:
9386 
        break
9387 
      if fid == 1:
3064 chandransh 9388 
        if ftype == TType.STRUCT:
9389 
          self.order = Order()
9390 
          self.order.read(iprot)
921 rajveer 9391 
        else:
9392 
          iprot.skip(ftype)
9393 
      else:
9394 
        iprot.skip(ftype)
9395 
      iprot.readFieldEnd()
9396 
    iprot.readStructEnd()
9397 
 
9398 
  def write(self, oprot):
9399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9401 
      return
3064 chandransh 9402 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 9403 
    if self.order is not None:
3064 chandransh 9404 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
9405 
      self.order.write(oprot)
921 rajveer 9406 
      oprot.writeFieldEnd()
9407 
    oprot.writeFieldStop()
9408 
    oprot.writeStructEnd()
9409 
 
3431 rajveer 9410 
  def validate(self):
9411 
    return
9412 
 
9413 
 
921 rajveer 9414 
  def __repr__(self):
9415 
    L = ['%s=%r' % (key, value)
9416 
      for key, value in self.__dict__.iteritems()]
9417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9418 
 
9419 
  def __eq__(self, other):
9420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9421 
 
9422 
  def __ne__(self, other):
9423 
    return not (self == other)
9424 
 
3064 chandransh 9425 
class createOrder_result:
921 rajveer 9426 
  """
9427 
  Attributes:
9428 
   - success
9429 
   - ex
9430 
  """
9431 
 
9432 
  thrift_spec = (
3064 chandransh 9433 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 9434 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9435 
  )
9436 
 
9437 
  def __init__(self, success=None, ex=None,):
9438 
    self.success = success
9439 
    self.ex = ex
9440 
 
9441 
  def read(self, iprot):
9442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9444 
      return
9445 
    iprot.readStructBegin()
9446 
    while True:
9447 
      (fname, ftype, fid) = iprot.readFieldBegin()
9448 
      if ftype == TType.STOP:
9449 
        break
9450 
      if fid == 0:
3064 chandransh 9451 
        if ftype == TType.I64:
9452 
          self.success = iprot.readI64();
921 rajveer 9453 
        else:
9454 
          iprot.skip(ftype)
9455 
      elif fid == 1:
9456 
        if ftype == TType.STRUCT:
9457 
          self.ex = TransactionServiceException()
9458 
          self.ex.read(iprot)
9459 
        else:
9460 
          iprot.skip(ftype)
9461 
      else:
9462 
        iprot.skip(ftype)
9463 
      iprot.readFieldEnd()
9464 
    iprot.readStructEnd()
9465 
 
9466 
  def write(self, oprot):
9467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9469 
      return
3064 chandransh 9470 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 9471 
    if self.success is not None:
3064 chandransh 9472 
      oprot.writeFieldBegin('success', TType.I64, 0)
9473 
      oprot.writeI64(self.success)
921 rajveer 9474 
      oprot.writeFieldEnd()
3431 rajveer 9475 
    if self.ex is not None:
921 rajveer 9476 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9477 
      self.ex.write(oprot)
9478 
      oprot.writeFieldEnd()
9479 
    oprot.writeFieldStop()
9480 
    oprot.writeStructEnd()
9481 
 
3431 rajveer 9482 
  def validate(self):
9483 
    return
9484 
 
9485 
 
921 rajveer 9486 
  def __repr__(self):
9487 
    L = ['%s=%r' % (key, value)
9488 
      for key, value in self.__dict__.iteritems()]
9489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9490 
 
9491 
  def __eq__(self, other):
9492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9493 
 
9494 
  def __ne__(self, other):
9495 
    return not (self == other)
9496 
 
3064 chandransh 9497 
class getOrder_args:
921 rajveer 9498 
  """
9499 
  Attributes:
3064 chandransh 9500 
   - id
921 rajveer 9501 
  """
9502 
 
9503 
  thrift_spec = (
9504 
    None, # 0
3064 chandransh 9505 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 9506 
  )
9507 
 
3064 chandransh 9508 
  def __init__(self, id=None,):
9509 
    self.id = id
921 rajveer 9510 
 
9511 
  def read(self, iprot):
9512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9514 
      return
9515 
    iprot.readStructBegin()
9516 
    while True:
9517 
      (fname, ftype, fid) = iprot.readFieldBegin()
9518 
      if ftype == TType.STOP:
9519 
        break
9520 
      if fid == 1:
9521 
        if ftype == TType.I64:
3064 chandransh 9522 
          self.id = iprot.readI64();
921 rajveer 9523 
        else:
9524 
          iprot.skip(ftype)
9525 
      else:
9526 
        iprot.skip(ftype)
9527 
      iprot.readFieldEnd()
9528 
    iprot.readStructEnd()
9529 
 
9530 
  def write(self, oprot):
9531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9533 
      return
3064 chandransh 9534 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 9535 
    if self.id is not None:
3064 chandransh 9536 
      oprot.writeFieldBegin('id', TType.I64, 1)
9537 
      oprot.writeI64(self.id)
921 rajveer 9538 
      oprot.writeFieldEnd()
9539 
    oprot.writeFieldStop()
9540 
    oprot.writeStructEnd()
9541 
 
3431 rajveer 9542 
  def validate(self):
9543 
    return
9544 
 
9545 
 
921 rajveer 9546 
  def __repr__(self):
9547 
    L = ['%s=%r' % (key, value)
9548 
      for key, value in self.__dict__.iteritems()]
9549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9550 
 
9551 
  def __eq__(self, other):
9552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9553 
 
9554 
  def __ne__(self, other):
9555 
    return not (self == other)
9556 
 
3064 chandransh 9557 
class getOrder_result:
921 rajveer 9558 
  """
9559 
  Attributes:
9560 
   - success
9561 
   - ex
9562 
  """
9563 
 
9564 
  thrift_spec = (
3064 chandransh 9565 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 9566 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9567 
  )
9568 
 
9569 
  def __init__(self, success=None, ex=None,):
9570 
    self.success = success
9571 
    self.ex = ex
9572 
 
9573 
  def read(self, iprot):
9574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9576 
      return
9577 
    iprot.readStructBegin()
9578 
    while True:
9579 
      (fname, ftype, fid) = iprot.readFieldBegin()
9580 
      if ftype == TType.STOP:
9581 
        break
9582 
      if fid == 0:
3064 chandransh 9583 
        if ftype == TType.STRUCT:
9584 
          self.success = Order()
9585 
          self.success.read(iprot)
921 rajveer 9586 
        else:
9587 
          iprot.skip(ftype)
9588 
      elif fid == 1:
9589 
        if ftype == TType.STRUCT:
9590 
          self.ex = TransactionServiceException()
9591 
          self.ex.read(iprot)
9592 
        else:
9593 
          iprot.skip(ftype)
9594 
      else:
9595 
        iprot.skip(ftype)
9596 
      iprot.readFieldEnd()
9597 
    iprot.readStructEnd()
9598 
 
9599 
  def write(self, oprot):
9600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9602 
      return
3064 chandransh 9603 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 9604 
    if self.success is not None:
3064 chandransh 9605 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9606 
      self.success.write(oprot)
921 rajveer 9607 
      oprot.writeFieldEnd()
3431 rajveer 9608 
    if self.ex is not None:
921 rajveer 9609 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9610 
      self.ex.write(oprot)
9611 
      oprot.writeFieldEnd()
9612 
    oprot.writeFieldStop()
9613 
    oprot.writeStructEnd()
9614 
 
3431 rajveer 9615 
  def validate(self):
9616 
    return
9617 
 
9618 
 
921 rajveer 9619 
  def __repr__(self):
9620 
    L = ['%s=%r' % (key, value)
9621 
      for key, value in self.__dict__.iteritems()]
9622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9623 
 
9624 
  def __eq__(self, other):
9625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9626 
 
9627 
  def __ne__(self, other):
9628 
    return not (self == other)
9629 
 
3064 chandransh 9630 
class getLineItemsForOrder_args:
94 ashish 9631 
  """
9632 
  Attributes:
3064 chandransh 9633 
   - orderId
94 ashish 9634 
  """
9635 
 
9636 
  thrift_spec = (
9637 
    None, # 0
3064 chandransh 9638 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 9639 
  )
9640 
 
3064 chandransh 9641 
  def __init__(self, orderId=None,):
9642 
    self.orderId = orderId
94 ashish 9643 
 
9644 
  def read(self, iprot):
9645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9647 
      return
9648 
    iprot.readStructBegin()
9649 
    while True:
9650 
      (fname, ftype, fid) = iprot.readFieldBegin()
9651 
      if ftype == TType.STOP:
9652 
        break
9653 
      if fid == 1:
9654 
        if ftype == TType.I64:
3064 chandransh 9655 
          self.orderId = iprot.readI64();
94 ashish 9656 
        else:
9657 
          iprot.skip(ftype)
9658 
      else:
9659 
        iprot.skip(ftype)
9660 
      iprot.readFieldEnd()
9661 
    iprot.readStructEnd()
9662 
 
9663 
  def write(self, oprot):
9664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9666 
      return
3064 chandransh 9667 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 9668 
    if self.orderId is not None:
3064 chandransh 9669 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9670 
      oprot.writeI64(self.orderId)
94 ashish 9671 
      oprot.writeFieldEnd()
9672 
    oprot.writeFieldStop()
9673 
    oprot.writeStructEnd()
9674 
 
3431 rajveer 9675 
  def validate(self):
9676 
    return
9677 
 
9678 
 
94 ashish 9679 
  def __repr__(self):
9680 
    L = ['%s=%r' % (key, value)
9681 
      for key, value in self.__dict__.iteritems()]
9682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9683 
 
9684 
  def __eq__(self, other):
9685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9686 
 
9687 
  def __ne__(self, other):
9688 
    return not (self == other)
9689 
 
3064 chandransh 9690 
class getLineItemsForOrder_result:
94 ashish 9691 
  """
9692 
  Attributes:
9693 
   - success
9694 
   - ex
9695 
  """
9696 
 
9697 
  thrift_spec = (
3064 chandransh 9698 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 9699 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9700 
  )
9701 
 
9702 
  def __init__(self, success=None, ex=None,):
9703 
    self.success = success
9704 
    self.ex = ex
9705 
 
9706 
  def read(self, iprot):
9707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9709 
      return
9710 
    iprot.readStructBegin()
9711 
    while True:
9712 
      (fname, ftype, fid) = iprot.readFieldBegin()
9713 
      if ftype == TType.STOP:
9714 
        break
9715 
      if fid == 0:
483 rajveer 9716 
        if ftype == TType.LIST:
9717 
          self.success = []
5031 varun.gupt 9718 
          (_etype164, _size161) = iprot.readListBegin()
9719 
          for _i165 in xrange(_size161):
9720 
            _elem166 = LineItem()
9721 
            _elem166.read(iprot)
9722 
            self.success.append(_elem166)
483 rajveer 9723 
          iprot.readListEnd()
94 ashish 9724 
        else:
9725 
          iprot.skip(ftype)
9726 
      elif fid == 1:
9727 
        if ftype == TType.STRUCT:
9728 
          self.ex = TransactionServiceException()
9729 
          self.ex.read(iprot)
9730 
        else:
9731 
          iprot.skip(ftype)
9732 
      else:
9733 
        iprot.skip(ftype)
9734 
      iprot.readFieldEnd()
9735 
    iprot.readStructEnd()
9736 
 
9737 
  def write(self, oprot):
9738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9740 
      return
3064 chandransh 9741 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 9742 
    if self.success is not None:
483 rajveer 9743 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9744 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9745 
      for iter167 in self.success:
9746 
        iter167.write(oprot)
483 rajveer 9747 
      oprot.writeListEnd()
94 ashish 9748 
      oprot.writeFieldEnd()
3431 rajveer 9749 
    if self.ex is not None:
94 ashish 9750 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9751 
      self.ex.write(oprot)
9752 
      oprot.writeFieldEnd()
9753 
    oprot.writeFieldStop()
9754 
    oprot.writeStructEnd()
9755 
 
3431 rajveer 9756 
  def validate(self):
9757 
    return
9758 
 
9759 
 
94 ashish 9760 
  def __repr__(self):
9761 
    L = ['%s=%r' % (key, value)
9762 
      for key, value in self.__dict__.iteritems()]
9763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9764 
 
9765 
  def __eq__(self, other):
9766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9767 
 
9768 
  def __ne__(self, other):
9769 
    return not (self == other)
9770 
 
4999 phani.kuma 9771 
class getOrderList_args:
9772 
  """
9773 
  Attributes:
9774 
   - order_ids
9775 
  """
9776 
 
9777 
  thrift_spec = (
9778 
    None, # 0
9779 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
9780 
  )
9781 
 
9782 
  def __init__(self, order_ids=None,):
9783 
    self.order_ids = order_ids
9784 
 
9785 
  def read(self, iprot):
9786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9788 
      return
9789 
    iprot.readStructBegin()
9790 
    while True:
9791 
      (fname, ftype, fid) = iprot.readFieldBegin()
9792 
      if ftype == TType.STOP:
9793 
        break
9794 
      if fid == 1:
9795 
        if ftype == TType.LIST:
9796 
          self.order_ids = []
5031 varun.gupt 9797 
          (_etype171, _size168) = iprot.readListBegin()
9798 
          for _i172 in xrange(_size168):
9799 
            _elem173 = iprot.readI64();
9800 
            self.order_ids.append(_elem173)
4999 phani.kuma 9801 
          iprot.readListEnd()
9802 
        else:
9803 
          iprot.skip(ftype)
9804 
      else:
9805 
        iprot.skip(ftype)
9806 
      iprot.readFieldEnd()
9807 
    iprot.readStructEnd()
9808 
 
9809 
  def write(self, oprot):
9810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9812 
      return
9813 
    oprot.writeStructBegin('getOrderList_args')
9814 
    if self.order_ids is not None:
9815 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
9816 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
5031 varun.gupt 9817 
      for iter174 in self.order_ids:
9818 
        oprot.writeI64(iter174)
4999 phani.kuma 9819 
      oprot.writeListEnd()
9820 
      oprot.writeFieldEnd()
9821 
    oprot.writeFieldStop()
9822 
    oprot.writeStructEnd()
9823 
 
9824 
  def validate(self):
9825 
    return
9826 
 
9827 
 
9828 
  def __repr__(self):
9829 
    L = ['%s=%r' % (key, value)
9830 
      for key, value in self.__dict__.iteritems()]
9831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9832 
 
9833 
  def __eq__(self, other):
9834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9835 
 
9836 
  def __ne__(self, other):
9837 
    return not (self == other)
9838 
 
9839 
class getOrderList_result:
9840 
  """
9841 
  Attributes:
9842 
   - success
9843 
  """
9844 
 
9845 
  thrift_spec = (
9846 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9847 
  )
9848 
 
9849 
  def __init__(self, success=None,):
9850 
    self.success = success
9851 
 
9852 
  def read(self, iprot):
9853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9855 
      return
9856 
    iprot.readStructBegin()
9857 
    while True:
9858 
      (fname, ftype, fid) = iprot.readFieldBegin()
9859 
      if ftype == TType.STOP:
9860 
        break
9861 
      if fid == 0:
9862 
        if ftype == TType.LIST:
9863 
          self.success = []
5031 varun.gupt 9864 
          (_etype178, _size175) = iprot.readListBegin()
9865 
          for _i179 in xrange(_size175):
9866 
            _elem180 = Order()
9867 
            _elem180.read(iprot)
9868 
            self.success.append(_elem180)
4999 phani.kuma 9869 
          iprot.readListEnd()
9870 
        else:
9871 
          iprot.skip(ftype)
9872 
      else:
9873 
        iprot.skip(ftype)
9874 
      iprot.readFieldEnd()
9875 
    iprot.readStructEnd()
9876 
 
9877 
  def write(self, oprot):
9878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9880 
      return
9881 
    oprot.writeStructBegin('getOrderList_result')
9882 
    if self.success is not None:
9883 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9884 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9885 
      for iter181 in self.success:
9886 
        iter181.write(oprot)
4999 phani.kuma 9887 
      oprot.writeListEnd()
9888 
      oprot.writeFieldEnd()
9889 
    oprot.writeFieldStop()
9890 
    oprot.writeStructEnd()
9891 
 
9892 
  def validate(self):
9893 
    return
9894 
 
9895 
 
9896 
  def __repr__(self):
9897 
    L = ['%s=%r' % (key, value)
9898 
      for key, value in self.__dict__.iteritems()]
9899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9900 
 
9901 
  def __eq__(self, other):
9902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9903 
 
9904 
  def __ne__(self, other):
9905 
    return not (self == other)
9906 
 
3064 chandransh 9907 
class getOrderForCustomer_args:
94 ashish 9908 
  """
9909 
  Attributes:
3064 chandransh 9910 
   - orderId
483 rajveer 9911 
   - customerId
94 ashish 9912 
  """
9913 
 
9914 
  thrift_spec = (
9915 
    None, # 0
3064 chandransh 9916 
    (1, TType.I64, 'orderId', None, None, ), # 1
9917 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 9918 
  )
9919 
 
3064 chandransh 9920 
  def __init__(self, orderId=None, customerId=None,):
9921 
    self.orderId = orderId
483 rajveer 9922 
    self.customerId = customerId
94 ashish 9923 
 
9924 
  def read(self, iprot):
9925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9927 
      return
9928 
    iprot.readStructBegin()
9929 
    while True:
9930 
      (fname, ftype, fid) = iprot.readFieldBegin()
9931 
      if ftype == TType.STOP:
9932 
        break
9933 
      if fid == 1:
9934 
        if ftype == TType.I64:
3064 chandransh 9935 
          self.orderId = iprot.readI64();
94 ashish 9936 
        else:
9937 
          iprot.skip(ftype)
9938 
      elif fid == 2:
9939 
        if ftype == TType.I64:
3064 chandransh 9940 
          self.customerId = iprot.readI64();
94 ashish 9941 
        else:
9942 
          iprot.skip(ftype)
9943 
      else:
9944 
        iprot.skip(ftype)
9945 
      iprot.readFieldEnd()
9946 
    iprot.readStructEnd()
9947 
 
9948 
  def write(self, oprot):
9949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9951 
      return
3064 chandransh 9952 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 9953 
    if self.orderId is not None:
3064 chandransh 9954 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9955 
      oprot.writeI64(self.orderId)
9956 
      oprot.writeFieldEnd()
3431 rajveer 9957 
    if self.customerId is not None:
3064 chandransh 9958 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 9959 
      oprot.writeI64(self.customerId)
94 ashish 9960 
      oprot.writeFieldEnd()
9961 
    oprot.writeFieldStop()
9962 
    oprot.writeStructEnd()
9963 
 
3431 rajveer 9964 
  def validate(self):
9965 
    return
9966 
 
9967 
 
94 ashish 9968 
  def __repr__(self):
9969 
    L = ['%s=%r' % (key, value)
9970 
      for key, value in self.__dict__.iteritems()]
9971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9972 
 
9973 
  def __eq__(self, other):
9974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9975 
 
9976 
  def __ne__(self, other):
9977 
    return not (self == other)
9978 
 
3064 chandransh 9979 
class getOrderForCustomer_result:
94 ashish 9980 
  """
9981 
  Attributes:
9982 
   - success
9983 
   - ex
9984 
  """
9985 
 
9986 
  thrift_spec = (
3064 chandransh 9987 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 9988 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9989 
  )
9990 
 
9991 
  def __init__(self, success=None, ex=None,):
9992 
    self.success = success
9993 
    self.ex = ex
9994 
 
9995 
  def read(self, iprot):
9996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9998 
      return
9999 
    iprot.readStructBegin()
10000 
    while True:
10001 
      (fname, ftype, fid) = iprot.readFieldBegin()
10002 
      if ftype == TType.STOP:
10003 
        break
10004 
      if fid == 0:
3064 chandransh 10005 
        if ftype == TType.STRUCT:
10006 
          self.success = Order()
10007 
          self.success.read(iprot)
94 ashish 10008 
        else:
10009 
          iprot.skip(ftype)
10010 
      elif fid == 1:
10011 
        if ftype == TType.STRUCT:
10012 
          self.ex = TransactionServiceException()
10013 
          self.ex.read(iprot)
10014 
        else:
10015 
          iprot.skip(ftype)
10016 
      else:
10017 
        iprot.skip(ftype)
10018 
      iprot.readFieldEnd()
10019 
    iprot.readStructEnd()
10020 
 
10021 
  def write(self, oprot):
10022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10024 
      return
3064 chandransh 10025 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 10026 
    if self.success is not None:
3064 chandransh 10027 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10028 
      self.success.write(oprot)
94 ashish 10029 
      oprot.writeFieldEnd()
3431 rajveer 10030 
    if self.ex is not None:
94 ashish 10031 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10032 
      self.ex.write(oprot)
10033 
      oprot.writeFieldEnd()
10034 
    oprot.writeFieldStop()
10035 
    oprot.writeStructEnd()
10036 
 
3431 rajveer 10037 
  def validate(self):
10038 
    return
10039 
 
10040 
 
94 ashish 10041 
  def __repr__(self):
10042 
    L = ['%s=%r' % (key, value)
10043 
      for key, value in self.__dict__.iteritems()]
10044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10045 
 
10046 
  def __eq__(self, other):
10047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10048 
 
10049 
  def __ne__(self, other):
10050 
    return not (self == other)
10051 
 
3064 chandransh 10052 
class getAlerts_args:
94 ashish 10053 
  """
10054 
  Attributes:
4394 rajveer 10055 
   - type
4444 rajveer 10056 
   - warehouseId
4394 rajveer 10057 
   - status
10058 
   - timestamp
94 ashish 10059 
  """
10060 
 
10061 
  thrift_spec = (
10062 
    None, # 0
4394 rajveer 10063 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10064 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10065 
    (3, TType.I64, 'status', None, None, ), # 3
10066 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 10067 
  )
10068 
 
4444 rajveer 10069 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 10070 
    self.type = type
4444 rajveer 10071 
    self.warehouseId = warehouseId
4394 rajveer 10072 
    self.status = status
10073 
    self.timestamp = timestamp
94 ashish 10074 
 
10075 
  def read(self, iprot):
10076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10078 
      return
10079 
    iprot.readStructBegin()
10080 
    while True:
10081 
      (fname, ftype, fid) = iprot.readFieldBegin()
10082 
      if ftype == TType.STOP:
10083 
        break
10084 
      if fid == 1:
3064 chandransh 10085 
        if ftype == TType.I64:
4394 rajveer 10086 
          self.type = iprot.readI64();
94 ashish 10087 
        else:
10088 
          iprot.skip(ftype)
3064 chandransh 10089 
      elif fid == 2:
4394 rajveer 10090 
        if ftype == TType.I64:
4444 rajveer 10091 
          self.warehouseId = iprot.readI64();
3064 chandransh 10092 
        else:
10093 
          iprot.skip(ftype)
4394 rajveer 10094 
      elif fid == 3:
10095 
        if ftype == TType.I64:
4444 rajveer 10096 
          self.status = iprot.readI64();
10097 
        else:
10098 
          iprot.skip(ftype)
10099 
      elif fid == 4:
10100 
        if ftype == TType.I64:
4394 rajveer 10101 
          self.timestamp = iprot.readI64();
10102 
        else:
10103 
          iprot.skip(ftype)
94 ashish 10104 
      else:
10105 
        iprot.skip(ftype)
10106 
      iprot.readFieldEnd()
10107 
    iprot.readStructEnd()
10108 
 
10109 
  def write(self, oprot):
10110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10112 
      return
3064 chandransh 10113 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 10114 
    if self.type is not None:
10115 
      oprot.writeFieldBegin('type', TType.I64, 1)
10116 
      oprot.writeI64(self.type)
94 ashish 10117 
      oprot.writeFieldEnd()
4444 rajveer 10118 
    if self.warehouseId is not None:
10119 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10120 
      oprot.writeI64(self.warehouseId)
10121 
      oprot.writeFieldEnd()
4394 rajveer 10122 
    if self.status is not None:
4444 rajveer 10123 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 10124 
      oprot.writeI64(self.status)
3064 chandransh 10125 
      oprot.writeFieldEnd()
4394 rajveer 10126 
    if self.timestamp is not None:
4444 rajveer 10127 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 10128 
      oprot.writeI64(self.timestamp)
10129 
      oprot.writeFieldEnd()
94 ashish 10130 
    oprot.writeFieldStop()
10131 
    oprot.writeStructEnd()
10132 
 
3431 rajveer 10133 
  def validate(self):
10134 
    return
10135 
 
10136 
 
94 ashish 10137 
  def __repr__(self):
10138 
    L = ['%s=%r' % (key, value)
10139 
      for key, value in self.__dict__.iteritems()]
10140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10141 
 
10142 
  def __eq__(self, other):
10143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10144 
 
10145 
  def __ne__(self, other):
10146 
    return not (self == other)
10147 
 
3064 chandransh 10148 
class getAlerts_result:
94 ashish 10149 
  """
10150 
  Attributes:
10151 
   - success
10152 
  """
10153 
 
10154 
  thrift_spec = (
3064 chandransh 10155 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 10156 
  )
10157 
 
3064 chandransh 10158 
  def __init__(self, success=None,):
94 ashish 10159 
    self.success = success
10160 
 
10161 
  def read(self, iprot):
10162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10164 
      return
10165 
    iprot.readStructBegin()
10166 
    while True:
10167 
      (fname, ftype, fid) = iprot.readFieldBegin()
10168 
      if ftype == TType.STOP:
10169 
        break
10170 
      if fid == 0:
3064 chandransh 10171 
        if ftype == TType.LIST:
10172 
          self.success = []
5031 varun.gupt 10173 
          (_etype185, _size182) = iprot.readListBegin()
10174 
          for _i186 in xrange(_size182):
10175 
            _elem187 = Alert()
10176 
            _elem187.read(iprot)
10177 
            self.success.append(_elem187)
3064 chandransh 10178 
          iprot.readListEnd()
94 ashish 10179 
        else:
10180 
          iprot.skip(ftype)
10181 
      else:
10182 
        iprot.skip(ftype)
10183 
      iprot.readFieldEnd()
10184 
    iprot.readStructEnd()
10185 
 
10186 
  def write(self, oprot):
10187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10189 
      return
3064 chandransh 10190 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 10191 
    if self.success is not None:
3064 chandransh 10192 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10193 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10194 
      for iter188 in self.success:
10195 
        iter188.write(oprot)
3064 chandransh 10196 
      oprot.writeListEnd()
94 ashish 10197 
      oprot.writeFieldEnd()
10198 
    oprot.writeFieldStop()
10199 
    oprot.writeStructEnd()
10200 
 
3431 rajveer 10201 
  def validate(self):
10202 
    return
10203 
 
10204 
 
94 ashish 10205 
  def __repr__(self):
10206 
    L = ['%s=%r' % (key, value)
10207 
      for key, value in self.__dict__.iteritems()]
10208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10209 
 
10210 
  def __eq__(self, other):
10211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10212 
 
10213 
  def __ne__(self, other):
10214 
    return not (self == other)
10215 
 
4394 rajveer 10216 
class addAlert_args:
94 ashish 10217 
  """
10218 
  Attributes:
3064 chandransh 10219 
   - type
4444 rajveer 10220 
   - warehouseId
4394 rajveer 10221 
   - description
94 ashish 10222 
  """
10223 
 
10224 
  thrift_spec = (
10225 
    None, # 0
4394 rajveer 10226 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10227 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10228 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10229 
  )
10230 
 
4444 rajveer 10231 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 10232 
    self.type = type
4444 rajveer 10233 
    self.warehouseId = warehouseId
4394 rajveer 10234 
    self.description = description
94 ashish 10235 
 
10236 
  def read(self, iprot):
10237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10239 
      return
10240 
    iprot.readStructBegin()
10241 
    while True:
10242 
      (fname, ftype, fid) = iprot.readFieldBegin()
10243 
      if ftype == TType.STOP:
10244 
        break
10245 
      if fid == 1:
10246 
        if ftype == TType.I64:
4394 rajveer 10247 
          self.type = iprot.readI64();
94 ashish 10248 
        else:
10249 
          iprot.skip(ftype)
3064 chandransh 10250 
      elif fid == 2:
4444 rajveer 10251 
        if ftype == TType.I64:
10252 
          self.warehouseId = iprot.readI64();
10253 
        else:
10254 
          iprot.skip(ftype)
10255 
      elif fid == 3:
3064 chandransh 10256 
        if ftype == TType.STRING:
4394 rajveer 10257 
          self.description = iprot.readString();
3064 chandransh 10258 
        else:
10259 
          iprot.skip(ftype)
94 ashish 10260 
      else:
10261 
        iprot.skip(ftype)
10262 
      iprot.readFieldEnd()
10263 
    iprot.readStructEnd()
10264 
 
10265 
  def write(self, oprot):
10266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10268 
      return
4394 rajveer 10269 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 10270 
    if self.type is not None:
4394 rajveer 10271 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 10272 
      oprot.writeI64(self.type)
10273 
      oprot.writeFieldEnd()
4444 rajveer 10274 
    if self.warehouseId is not None:
10275 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10276 
      oprot.writeI64(self.warehouseId)
10277 
      oprot.writeFieldEnd()
4394 rajveer 10278 
    if self.description is not None:
4444 rajveer 10279 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 10280 
      oprot.writeString(self.description)
3064 chandransh 10281 
      oprot.writeFieldEnd()
94 ashish 10282 
    oprot.writeFieldStop()
10283 
    oprot.writeStructEnd()
10284 
 
3431 rajveer 10285 
  def validate(self):
10286 
    return
10287 
 
10288 
 
94 ashish 10289 
  def __repr__(self):
10290 
    L = ['%s=%r' % (key, value)
10291 
      for key, value in self.__dict__.iteritems()]
10292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10293 
 
10294 
  def __eq__(self, other):
10295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10296 
 
10297 
  def __ne__(self, other):
10298 
    return not (self == other)
10299 
 
4394 rajveer 10300 
class addAlert_result:
3064 chandransh 10301 
 
10302 
  thrift_spec = (
10303 
  )
10304 
 
10305 
  def read(self, iprot):
10306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10308 
      return
10309 
    iprot.readStructBegin()
10310 
    while True:
10311 
      (fname, ftype, fid) = iprot.readFieldBegin()
10312 
      if ftype == TType.STOP:
10313 
        break
10314 
      else:
10315 
        iprot.skip(ftype)
10316 
      iprot.readFieldEnd()
10317 
    iprot.readStructEnd()
10318 
 
10319 
  def write(self, oprot):
10320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10322 
      return
4394 rajveer 10323 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 10324 
    oprot.writeFieldStop()
10325 
    oprot.writeStructEnd()
10326 
 
3431 rajveer 10327 
  def validate(self):
10328 
    return
10329 
 
10330 
 
3064 chandransh 10331 
  def __repr__(self):
10332 
    L = ['%s=%r' % (key, value)
10333 
      for key, value in self.__dict__.iteritems()]
10334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10335 
 
10336 
  def __eq__(self, other):
10337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10338 
 
10339 
  def __ne__(self, other):
10340 
    return not (self == other)
10341 
 
4444 rajveer 10342 
class markAlertsAsSeen_args:
10343 
  """
10344 
  Attributes:
10345 
   - warehouseId
10346 
  """
10347 
 
10348 
  thrift_spec = (
10349 
    None, # 0
10350 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10351 
  )
10352 
 
10353 
  def __init__(self, warehouseId=None,):
10354 
    self.warehouseId = warehouseId
10355 
 
10356 
  def read(self, iprot):
10357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10359 
      return
10360 
    iprot.readStructBegin()
10361 
    while True:
10362 
      (fname, ftype, fid) = iprot.readFieldBegin()
10363 
      if ftype == TType.STOP:
10364 
        break
10365 
      if fid == 1:
10366 
        if ftype == TType.I64:
10367 
          self.warehouseId = iprot.readI64();
10368 
        else:
10369 
          iprot.skip(ftype)
10370 
      else:
10371 
        iprot.skip(ftype)
10372 
      iprot.readFieldEnd()
10373 
    iprot.readStructEnd()
10374 
 
10375 
  def write(self, oprot):
10376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10378 
      return
10379 
    oprot.writeStructBegin('markAlertsAsSeen_args')
10380 
    if self.warehouseId is not None:
10381 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10382 
      oprot.writeI64(self.warehouseId)
10383 
      oprot.writeFieldEnd()
10384 
    oprot.writeFieldStop()
10385 
    oprot.writeStructEnd()
10386 
 
10387 
  def validate(self):
10388 
    return
10389 
 
10390 
 
10391 
  def __repr__(self):
10392 
    L = ['%s=%r' % (key, value)
10393 
      for key, value in self.__dict__.iteritems()]
10394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10395 
 
10396 
  def __eq__(self, other):
10397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10398 
 
10399 
  def __ne__(self, other):
10400 
    return not (self == other)
10401 
 
10402 
class markAlertsAsSeen_result:
10403 
 
10404 
  thrift_spec = (
10405 
  )
10406 
 
10407 
  def read(self, iprot):
10408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10410 
      return
10411 
    iprot.readStructBegin()
10412 
    while True:
10413 
      (fname, ftype, fid) = iprot.readFieldBegin()
10414 
      if ftype == TType.STOP:
10415 
        break
10416 
      else:
10417 
        iprot.skip(ftype)
10418 
      iprot.readFieldEnd()
10419 
    iprot.readStructEnd()
10420 
 
10421 
  def write(self, oprot):
10422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10424 
      return
10425 
    oprot.writeStructBegin('markAlertsAsSeen_result')
10426 
    oprot.writeFieldStop()
10427 
    oprot.writeStructEnd()
10428 
 
10429 
  def validate(self):
10430 
    return
10431 
 
10432 
 
10433 
  def __repr__(self):
10434 
    L = ['%s=%r' % (key, value)
10435 
      for key, value in self.__dict__.iteritems()]
10436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10437 
 
10438 
  def __eq__(self, other):
10439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10440 
 
10441 
  def __ne__(self, other):
10442 
    return not (self == other)
10443 
 
3064 chandransh 10444 
class getValidOrderCount_args:
10445 
 
10446 
  thrift_spec = (
10447 
  )
10448 
 
10449 
  def read(self, iprot):
10450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10452 
      return
10453 
    iprot.readStructBegin()
10454 
    while True:
10455 
      (fname, ftype, fid) = iprot.readFieldBegin()
10456 
      if ftype == TType.STOP:
10457 
        break
10458 
      else:
10459 
        iprot.skip(ftype)
10460 
      iprot.readFieldEnd()
10461 
    iprot.readStructEnd()
10462 
 
10463 
  def write(self, oprot):
10464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10466 
      return
10467 
    oprot.writeStructBegin('getValidOrderCount_args')
10468 
    oprot.writeFieldStop()
10469 
    oprot.writeStructEnd()
10470 
 
3431 rajveer 10471 
  def validate(self):
10472 
    return
10473 
 
10474 
 
3064 chandransh 10475 
  def __repr__(self):
10476 
    L = ['%s=%r' % (key, value)
10477 
      for key, value in self.__dict__.iteritems()]
10478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10479 
 
10480 
  def __eq__(self, other):
10481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10482 
 
10483 
  def __ne__(self, other):
10484 
    return not (self == other)
10485 
 
10486 
class getValidOrderCount_result:
94 ashish 10487 
  """
10488 
  Attributes:
10489 
   - success
10490 
  """
10491 
 
10492 
  thrift_spec = (
3064 chandransh 10493 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10494 
  )
10495 
 
3064 chandransh 10496 
  def __init__(self, success=None,):
94 ashish 10497 
    self.success = success
10498 
 
10499 
  def read(self, iprot):
10500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10502 
      return
10503 
    iprot.readStructBegin()
10504 
    while True:
10505 
      (fname, ftype, fid) = iprot.readFieldBegin()
10506 
      if ftype == TType.STOP:
10507 
        break
10508 
      if fid == 0:
3064 chandransh 10509 
        if ftype == TType.I64:
10510 
          self.success = iprot.readI64();
94 ashish 10511 
        else:
10512 
          iprot.skip(ftype)
10513 
      else:
10514 
        iprot.skip(ftype)
10515 
      iprot.readFieldEnd()
10516 
    iprot.readStructEnd()
10517 
 
10518 
  def write(self, oprot):
10519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10521 
      return
3064 chandransh 10522 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 10523 
    if self.success is not None:
3064 chandransh 10524 
      oprot.writeFieldBegin('success', TType.I64, 0)
10525 
      oprot.writeI64(self.success)
94 ashish 10526 
      oprot.writeFieldEnd()
10527 
    oprot.writeFieldStop()
10528 
    oprot.writeStructEnd()
10529 
 
3431 rajveer 10530 
  def validate(self):
10531 
    return
10532 
 
10533 
 
94 ashish 10534 
  def __repr__(self):
10535 
    L = ['%s=%r' % (key, value)
10536 
      for key, value in self.__dict__.iteritems()]
10537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10538 
 
10539 
  def __eq__(self, other):
10540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10541 
 
10542 
  def __ne__(self, other):
10543 
    return not (self == other)
10544 
 
3064 chandransh 10545 
class getNoOfCustomersWithSuccessfulTransaction_args:
10546 
 
10547 
  thrift_spec = (
10548 
  )
10549 
 
10550 
  def read(self, iprot):
10551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10553 
      return
10554 
    iprot.readStructBegin()
10555 
    while True:
10556 
      (fname, ftype, fid) = iprot.readFieldBegin()
10557 
      if ftype == TType.STOP:
10558 
        break
10559 
      else:
10560 
        iprot.skip(ftype)
10561 
      iprot.readFieldEnd()
10562 
    iprot.readStructEnd()
10563 
 
10564 
  def write(self, oprot):
10565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10567 
      return
10568 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
10569 
    oprot.writeFieldStop()
10570 
    oprot.writeStructEnd()
10571 
 
3431 rajveer 10572 
  def validate(self):
10573 
    return
10574 
 
10575 
 
3064 chandransh 10576 
  def __repr__(self):
10577 
    L = ['%s=%r' % (key, value)
10578 
      for key, value in self.__dict__.iteritems()]
10579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10580 
 
10581 
  def __eq__(self, other):
10582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10583 
 
10584 
  def __ne__(self, other):
10585 
    return not (self == other)
10586 
 
10587 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 10588 
  """
10589 
  Attributes:
3064 chandransh 10590 
   - success
94 ashish 10591 
  """
10592 
 
10593 
  thrift_spec = (
3064 chandransh 10594 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10595 
  )
10596 
 
3064 chandransh 10597 
  def __init__(self, success=None,):
10598 
    self.success = success
94 ashish 10599 
 
10600 
  def read(self, iprot):
10601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10603 
      return
10604 
    iprot.readStructBegin()
10605 
    while True:
10606 
      (fname, ftype, fid) = iprot.readFieldBegin()
10607 
      if ftype == TType.STOP:
10608 
        break
3064 chandransh 10609 
      if fid == 0:
94 ashish 10610 
        if ftype == TType.I64:
3064 chandransh 10611 
          self.success = iprot.readI64();
94 ashish 10612 
        else:
10613 
          iprot.skip(ftype)
10614 
      else:
10615 
        iprot.skip(ftype)
10616 
      iprot.readFieldEnd()
10617 
    iprot.readStructEnd()
10618 
 
10619 
  def write(self, oprot):
10620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10622 
      return
3064 chandransh 10623 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 10624 
    if self.success is not None:
3064 chandransh 10625 
      oprot.writeFieldBegin('success', TType.I64, 0)
10626 
      oprot.writeI64(self.success)
94 ashish 10627 
      oprot.writeFieldEnd()
10628 
    oprot.writeFieldStop()
10629 
    oprot.writeStructEnd()
10630 
 
3431 rajveer 10631 
  def validate(self):
10632 
    return
10633 
 
10634 
 
94 ashish 10635 
  def __repr__(self):
10636 
    L = ['%s=%r' % (key, value)
10637 
      for key, value in self.__dict__.iteritems()]
10638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10639 
 
10640 
  def __eq__(self, other):
10641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10642 
 
10643 
  def __ne__(self, other):
10644 
    return not (self == other)
10645 
 
3064 chandransh 10646 
class getValidOrdersAmountRange_args:
10647 
 
10648 
  thrift_spec = (
10649 
  )
10650 
 
10651 
  def read(self, iprot):
10652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10654 
      return
10655 
    iprot.readStructBegin()
10656 
    while True:
10657 
      (fname, ftype, fid) = iprot.readFieldBegin()
10658 
      if ftype == TType.STOP:
10659 
        break
10660 
      else:
10661 
        iprot.skip(ftype)
10662 
      iprot.readFieldEnd()
10663 
    iprot.readStructEnd()
10664 
 
10665 
  def write(self, oprot):
10666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10668 
      return
10669 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
10670 
    oprot.writeFieldStop()
10671 
    oprot.writeStructEnd()
10672 
 
3431 rajveer 10673 
  def validate(self):
10674 
    return
10675 
 
10676 
 
3064 chandransh 10677 
  def __repr__(self):
10678 
    L = ['%s=%r' % (key, value)
10679 
      for key, value in self.__dict__.iteritems()]
10680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10681 
 
10682 
  def __eq__(self, other):
10683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10684 
 
10685 
  def __ne__(self, other):
10686 
    return not (self == other)
10687 
 
10688 
class getValidOrdersAmountRange_result:
94 ashish 10689 
  """
10690 
  Attributes:
10691 
   - success
10692 
  """
10693 
 
10694 
  thrift_spec = (
3064 chandransh 10695 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 10696 
  )
10697 
 
3064 chandransh 10698 
  def __init__(self, success=None,):
94 ashish 10699 
    self.success = success
10700 
 
10701 
  def read(self, iprot):
10702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10704 
      return
10705 
    iprot.readStructBegin()
10706 
    while True:
10707 
      (fname, ftype, fid) = iprot.readFieldBegin()
10708 
      if ftype == TType.STOP:
10709 
        break
10710 
      if fid == 0:
483 rajveer 10711 
        if ftype == TType.LIST:
10712 
          self.success = []
5031 varun.gupt 10713 
          (_etype192, _size189) = iprot.readListBegin()
10714 
          for _i193 in xrange(_size189):
10715 
            _elem194 = iprot.readDouble();
10716 
            self.success.append(_elem194)
483 rajveer 10717 
          iprot.readListEnd()
94 ashish 10718 
        else:
10719 
          iprot.skip(ftype)
10720 
      else:
10721 
        iprot.skip(ftype)
10722 
      iprot.readFieldEnd()
10723 
    iprot.readStructEnd()
10724 
 
10725 
  def write(self, oprot):
10726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10728 
      return
3064 chandransh 10729 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 10730 
    if self.success is not None:
483 rajveer 10731 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 10732 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
5031 varun.gupt 10733 
      for iter195 in self.success:
10734 
        oprot.writeDouble(iter195)
483 rajveer 10735 
      oprot.writeListEnd()
94 ashish 10736 
      oprot.writeFieldEnd()
10737 
    oprot.writeFieldStop()
10738 
    oprot.writeStructEnd()
10739 
 
3431 rajveer 10740 
  def validate(self):
10741 
    return
10742 
 
10743 
 
94 ashish 10744 
  def __repr__(self):
10745 
    L = ['%s=%r' % (key, value)
10746 
      for key, value in self.__dict__.iteritems()]
10747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10748 
 
10749 
  def __eq__(self, other):
10750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10751 
 
10752 
  def __ne__(self, other):
10753 
    return not (self == other)
10754 
 
3064 chandransh 10755 
class getValidOrders_args:
1528 ankur.sing 10756 
  """
10757 
  Attributes:
3064 chandransh 10758 
   - limit
1528 ankur.sing 10759 
  """
10760 
 
10761 
  thrift_spec = (
10762 
    None, # 0
3064 chandransh 10763 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 10764 
  )
10765 
 
3064 chandransh 10766 
  def __init__(self, limit=None,):
10767 
    self.limit = limit
1528 ankur.sing 10768 
 
10769 
  def read(self, iprot):
10770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10772 
      return
10773 
    iprot.readStructBegin()
10774 
    while True:
10775 
      (fname, ftype, fid) = iprot.readFieldBegin()
10776 
      if ftype == TType.STOP:
10777 
        break
10778 
      if fid == 1:
10779 
        if ftype == TType.I64:
3064 chandransh 10780 
          self.limit = iprot.readI64();
1528 ankur.sing 10781 
        else:
10782 
          iprot.skip(ftype)
10783 
      else:
10784 
        iprot.skip(ftype)
10785 
      iprot.readFieldEnd()
10786 
    iprot.readStructEnd()
10787 
 
10788 
  def write(self, oprot):
10789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10791 
      return
3064 chandransh 10792 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 10793 
    if self.limit is not None:
3064 chandransh 10794 
      oprot.writeFieldBegin('limit', TType.I64, 1)
10795 
      oprot.writeI64(self.limit)
1528 ankur.sing 10796 
      oprot.writeFieldEnd()
10797 
    oprot.writeFieldStop()
10798 
    oprot.writeStructEnd()
10799 
 
3431 rajveer 10800 
  def validate(self):
10801 
    return
10802 
 
10803 
 
1528 ankur.sing 10804 
  def __repr__(self):
10805 
    L = ['%s=%r' % (key, value)
10806 
      for key, value in self.__dict__.iteritems()]
10807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10808 
 
10809 
  def __eq__(self, other):
10810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10811 
 
10812 
  def __ne__(self, other):
10813 
    return not (self == other)
10814 
 
3064 chandransh 10815 
class getValidOrders_result:
1528 ankur.sing 10816 
  """
10817 
  Attributes:
10818 
   - success
10819 
  """
10820 
 
10821 
  thrift_spec = (
3064 chandransh 10822 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 10823 
  )
10824 
 
3064 chandransh 10825 
  def __init__(self, success=None,):
1528 ankur.sing 10826 
    self.success = success
10827 
 
10828 
  def read(self, iprot):
10829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10831 
      return
10832 
    iprot.readStructBegin()
10833 
    while True:
10834 
      (fname, ftype, fid) = iprot.readFieldBegin()
10835 
      if ftype == TType.STOP:
10836 
        break
10837 
      if fid == 0:
3064 chandransh 10838 
        if ftype == TType.LIST:
10839 
          self.success = []
5031 varun.gupt 10840 
          (_etype199, _size196) = iprot.readListBegin()
10841 
          for _i200 in xrange(_size196):
10842 
            _elem201 = Order()
10843 
            _elem201.read(iprot)
10844 
            self.success.append(_elem201)
3064 chandransh 10845 
          iprot.readListEnd()
1528 ankur.sing 10846 
        else:
10847 
          iprot.skip(ftype)
10848 
      else:
10849 
        iprot.skip(ftype)
10850 
      iprot.readFieldEnd()
10851 
    iprot.readStructEnd()
10852 
 
10853 
  def write(self, oprot):
10854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10856 
      return
3064 chandransh 10857 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 10858 
    if self.success is not None:
3064 chandransh 10859 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10860 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10861 
      for iter202 in self.success:
10862 
        iter202.write(oprot)
3064 chandransh 10863 
      oprot.writeListEnd()
1528 ankur.sing 10864 
      oprot.writeFieldEnd()
10865 
    oprot.writeFieldStop()
10866 
    oprot.writeStructEnd()
10867 
 
3431 rajveer 10868 
  def validate(self):
10869 
    return
10870 
 
10871 
 
1528 ankur.sing 10872 
  def __repr__(self):
10873 
    L = ['%s=%r' % (key, value)
10874 
      for key, value in self.__dict__.iteritems()]
10875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10876 
 
10877 
  def __eq__(self, other):
10878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10879 
 
10880 
  def __ne__(self, other):
10881 
    return not (self == other)
10882 
 
1220 chandransh 10883 
class batchOrders_args:
10884 
  """
10885 
  Attributes:
10886 
   - warehouseId
10887 
  """
10888 
 
10889 
  thrift_spec = (
10890 
    None, # 0
10891 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10892 
  )
10893 
 
10894 
  def __init__(self, warehouseId=None,):
10895 
    self.warehouseId = warehouseId
10896 
 
10897 
  def read(self, iprot):
10898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10900 
      return
10901 
    iprot.readStructBegin()
10902 
    while True:
10903 
      (fname, ftype, fid) = iprot.readFieldBegin()
10904 
      if ftype == TType.STOP:
10905 
        break
10906 
      if fid == 1:
10907 
        if ftype == TType.I64:
10908 
          self.warehouseId = iprot.readI64();
10909 
        else:
10910 
          iprot.skip(ftype)
10911 
      else:
10912 
        iprot.skip(ftype)
10913 
      iprot.readFieldEnd()
10914 
    iprot.readStructEnd()
10915 
 
10916 
  def write(self, oprot):
10917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10919 
      return
10920 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 10921 
    if self.warehouseId is not None:
1220 chandransh 10922 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10923 
      oprot.writeI64(self.warehouseId)
10924 
      oprot.writeFieldEnd()
10925 
    oprot.writeFieldStop()
10926 
    oprot.writeStructEnd()
10927 
 
3431 rajveer 10928 
  def validate(self):
10929 
    return
10930 
 
10931 
 
1220 chandransh 10932 
  def __repr__(self):
10933 
    L = ['%s=%r' % (key, value)
10934 
      for key, value in self.__dict__.iteritems()]
10935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10936 
 
10937 
  def __eq__(self, other):
10938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10939 
 
10940 
  def __ne__(self, other):
10941 
    return not (self == other)
10942 
 
10943 
class batchOrders_result:
10944 
  """
10945 
  Attributes:
10946 
   - success
10947 
   - ex
10948 
  """
10949 
 
10950 
  thrift_spec = (
10951 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10952 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10953 
  )
10954 
 
10955 
  def __init__(self, success=None, ex=None,):
10956 
    self.success = success
10957 
    self.ex = ex
10958 
 
10959 
  def read(self, iprot):
10960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10962 
      return
10963 
    iprot.readStructBegin()
10964 
    while True:
10965 
      (fname, ftype, fid) = iprot.readFieldBegin()
10966 
      if ftype == TType.STOP:
10967 
        break
10968 
      if fid == 0:
10969 
        if ftype == TType.LIST:
10970 
          self.success = []
5031 varun.gupt 10971 
          (_etype206, _size203) = iprot.readListBegin()
10972 
          for _i207 in xrange(_size203):
10973 
            _elem208 = Order()
10974 
            _elem208.read(iprot)
10975 
            self.success.append(_elem208)
1220 chandransh 10976 
          iprot.readListEnd()
10977 
        else:
10978 
          iprot.skip(ftype)
10979 
      elif fid == 1:
10980 
        if ftype == TType.STRUCT:
10981 
          self.ex = TransactionServiceException()
10982 
          self.ex.read(iprot)
10983 
        else:
10984 
          iprot.skip(ftype)
10985 
      else:
10986 
        iprot.skip(ftype)
10987 
      iprot.readFieldEnd()
10988 
    iprot.readStructEnd()
10989 
 
10990 
  def write(self, oprot):
10991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10993 
      return
10994 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 10995 
    if self.success is not None:
1220 chandransh 10996 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10997 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10998 
      for iter209 in self.success:
10999 
        iter209.write(oprot)
1220 chandransh 11000 
      oprot.writeListEnd()
11001 
      oprot.writeFieldEnd()
3431 rajveer 11002 
    if self.ex is not None:
1220 chandransh 11003 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11004 
      self.ex.write(oprot)
11005 
      oprot.writeFieldEnd()
11006 
    oprot.writeFieldStop()
11007 
    oprot.writeStructEnd()
11008 
 
3431 rajveer 11009 
  def validate(self):
11010 
    return
11011 
 
11012 
 
1220 chandransh 11013 
  def __repr__(self):
11014 
    L = ['%s=%r' % (key, value)
11015 
      for key, value in self.__dict__.iteritems()]
11016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11017 
 
11018 
  def __eq__(self, other):
11019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11020 
 
11021 
  def __ne__(self, other):
11022 
    return not (self == other)
11023 
 
1208 chandransh 11024 
class markOrderAsOutOfStock_args:
11025 
  """
11026 
  Attributes:
11027 
   - orderId
11028 
  """
11029 
 
11030 
  thrift_spec = (
11031 
    None, # 0
11032 
    (1, TType.I64, 'orderId', None, None, ), # 1
11033 
  )
11034 
 
11035 
  def __init__(self, orderId=None,):
11036 
    self.orderId = orderId
11037 
 
11038 
  def read(self, iprot):
11039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11041 
      return
11042 
    iprot.readStructBegin()
11043 
    while True:
11044 
      (fname, ftype, fid) = iprot.readFieldBegin()
11045 
      if ftype == TType.STOP:
11046 
        break
11047 
      if fid == 1:
11048 
        if ftype == TType.I64:
11049 
          self.orderId = iprot.readI64();
11050 
        else:
11051 
          iprot.skip(ftype)
11052 
      else:
11053 
        iprot.skip(ftype)
11054 
      iprot.readFieldEnd()
11055 
    iprot.readStructEnd()
11056 
 
11057 
  def write(self, oprot):
11058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11060 
      return
11061 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 11062 
    if self.orderId is not None:
1208 chandransh 11063 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11064 
      oprot.writeI64(self.orderId)
11065 
      oprot.writeFieldEnd()
11066 
    oprot.writeFieldStop()
11067 
    oprot.writeStructEnd()
11068 
 
3431 rajveer 11069 
  def validate(self):
11070 
    return
11071 
 
11072 
 
1208 chandransh 11073 
  def __repr__(self):
11074 
    L = ['%s=%r' % (key, value)
11075 
      for key, value in self.__dict__.iteritems()]
11076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11077 
 
11078 
  def __eq__(self, other):
11079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11080 
 
11081 
  def __ne__(self, other):
11082 
    return not (self == other)
11083 
 
11084 
class markOrderAsOutOfStock_result:
11085 
  """
11086 
  Attributes:
11087 
   - success
11088 
   - ex
11089 
  """
11090 
 
11091 
  thrift_spec = (
11092 
    (0, TType.BOOL, 'success', None, None, ), # 0
11093 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11094 
  )
11095 
 
11096 
  def __init__(self, success=None, ex=None,):
11097 
    self.success = success
11098 
    self.ex = ex
11099 
 
11100 
  def read(self, iprot):
11101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11103 
      return
11104 
    iprot.readStructBegin()
11105 
    while True:
11106 
      (fname, ftype, fid) = iprot.readFieldBegin()
11107 
      if ftype == TType.STOP:
11108 
        break
11109 
      if fid == 0:
11110 
        if ftype == TType.BOOL:
11111 
          self.success = iprot.readBool();
11112 
        else:
11113 
          iprot.skip(ftype)
11114 
      elif fid == 1:
11115 
        if ftype == TType.STRUCT:
11116 
          self.ex = TransactionServiceException()
11117 
          self.ex.read(iprot)
11118 
        else:
11119 
          iprot.skip(ftype)
11120 
      else:
11121 
        iprot.skip(ftype)
11122 
      iprot.readFieldEnd()
11123 
    iprot.readStructEnd()
11124 
 
11125 
  def write(self, oprot):
11126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11128 
      return
11129 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 11130 
    if self.success is not None:
1208 chandransh 11131 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11132 
      oprot.writeBool(self.success)
11133 
      oprot.writeFieldEnd()
3431 rajveer 11134 
    if self.ex is not None:
1208 chandransh 11135 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11136 
      self.ex.write(oprot)
11137 
      oprot.writeFieldEnd()
11138 
    oprot.writeFieldStop()
11139 
    oprot.writeStructEnd()
11140 
 
3431 rajveer 11141 
  def validate(self):
11142 
    return
11143 
 
11144 
 
1208 chandransh 11145 
  def __repr__(self):
11146 
    L = ['%s=%r' % (key, value)
11147 
      for key, value in self.__dict__.iteritems()]
11148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11149 
 
11150 
  def __eq__(self, other):
11151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11152 
 
11153 
  def __ne__(self, other):
11154 
    return not (self == other)
11155 
 
3064 chandransh 11156 
class verifyOrder_args:
759 chandransh 11157 
  """
11158 
  Attributes:
3064 chandransh 11159 
   - orderId
759 chandransh 11160 
  """
11161 
 
11162 
  thrift_spec = (
11163 
    None, # 0
3064 chandransh 11164 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 11165 
  )
11166 
 
3064 chandransh 11167 
  def __init__(self, orderId=None,):
11168 
    self.orderId = orderId
759 chandransh 11169 
 
11170 
  def read(self, iprot):
11171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11173 
      return
11174 
    iprot.readStructBegin()
11175 
    while True:
11176 
      (fname, ftype, fid) = iprot.readFieldBegin()
11177 
      if ftype == TType.STOP:
11178 
        break
11179 
      if fid == 1:
11180 
        if ftype == TType.I64:
3064 chandransh 11181 
          self.orderId = iprot.readI64();
759 chandransh 11182 
        else:
11183 
          iprot.skip(ftype)
11184 
      else:
11185 
        iprot.skip(ftype)
11186 
      iprot.readFieldEnd()
11187 
    iprot.readStructEnd()
11188 
 
11189 
  def write(self, oprot):
11190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11192 
      return
3064 chandransh 11193 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 11194 
    if self.orderId is not None:
3064 chandransh 11195 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11196 
      oprot.writeI64(self.orderId)
759 chandransh 11197 
      oprot.writeFieldEnd()
11198 
    oprot.writeFieldStop()
11199 
    oprot.writeStructEnd()
11200 
 
3431 rajveer 11201 
  def validate(self):
11202 
    return
11203 
 
11204 
 
759 chandransh 11205 
  def __repr__(self):
11206 
    L = ['%s=%r' % (key, value)
11207 
      for key, value in self.__dict__.iteritems()]
11208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11209 
 
11210 
  def __eq__(self, other):
11211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11212 
 
11213 
  def __ne__(self, other):
11214 
    return not (self == other)
11215 
 
3064 chandransh 11216 
class verifyOrder_result:
759 chandransh 11217 
  """
11218 
  Attributes:
11219 
   - success
11220 
   - ex
11221 
  """
11222 
 
11223 
  thrift_spec = (
11224 
    (0, TType.BOOL, 'success', None, None, ), # 0
11225 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11226 
  )
11227 
 
11228 
  def __init__(self, success=None, ex=None,):
11229 
    self.success = success
11230 
    self.ex = ex
11231 
 
11232 
  def read(self, iprot):
11233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11235 
      return
11236 
    iprot.readStructBegin()
11237 
    while True:
11238 
      (fname, ftype, fid) = iprot.readFieldBegin()
11239 
      if ftype == TType.STOP:
11240 
        break
11241 
      if fid == 0:
11242 
        if ftype == TType.BOOL:
11243 
          self.success = iprot.readBool();
11244 
        else:
11245 
          iprot.skip(ftype)
11246 
      elif fid == 1:
11247 
        if ftype == TType.STRUCT:
11248 
          self.ex = TransactionServiceException()
11249 
          self.ex.read(iprot)
11250 
        else:
11251 
          iprot.skip(ftype)
11252 
      else:
11253 
        iprot.skip(ftype)
11254 
      iprot.readFieldEnd()
11255 
    iprot.readStructEnd()
11256 
 
11257 
  def write(self, oprot):
11258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11260 
      return
3064 chandransh 11261 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 11262 
    if self.success is not None:
759 chandransh 11263 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11264 
      oprot.writeBool(self.success)
11265 
      oprot.writeFieldEnd()
3431 rajveer 11266 
    if self.ex is not None:
759 chandransh 11267 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11268 
      self.ex.write(oprot)
11269 
      oprot.writeFieldEnd()
11270 
    oprot.writeFieldStop()
11271 
    oprot.writeStructEnd()
11272 
 
3431 rajveer 11273 
  def validate(self):
11274 
    return
11275 
 
11276 
 
759 chandransh 11277 
  def __repr__(self):
11278 
    L = ['%s=%r' % (key, value)
11279 
      for key, value in self.__dict__.iteritems()]
11280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11281 
 
11282 
  def __eq__(self, other):
11283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11284 
 
11285 
  def __ne__(self, other):
11286 
    return not (self == other)
11287 
 
3064 chandransh 11288 
class acceptOrder_args:
1113 chandransh 11289 
  """
11290 
  Attributes:
3064 chandransh 11291 
   - orderId
1113 chandransh 11292 
  """
11293 
 
11294 
  thrift_spec = (
11295 
    None, # 0
3064 chandransh 11296 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 11297 
  )
11298 
 
3064 chandransh 11299 
  def __init__(self, orderId=None,):
11300 
    self.orderId = orderId
1113 chandransh 11301 
 
11302 
  def read(self, iprot):
11303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11305 
      return
11306 
    iprot.readStructBegin()
11307 
    while True:
11308 
      (fname, ftype, fid) = iprot.readFieldBegin()
11309 
      if ftype == TType.STOP:
11310 
        break
11311 
      if fid == 1:
11312 
        if ftype == TType.I64:
3064 chandransh 11313 
          self.orderId = iprot.readI64();
1113 chandransh 11314 
        else:
11315 
          iprot.skip(ftype)
11316 
      else:
11317 
        iprot.skip(ftype)
11318 
      iprot.readFieldEnd()
11319 
    iprot.readStructEnd()
11320 
 
11321 
  def write(self, oprot):
11322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11324 
      return
3064 chandransh 11325 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 11326 
    if self.orderId is not None:
3064 chandransh 11327 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11328 
      oprot.writeI64(self.orderId)
1113 chandransh 11329 
      oprot.writeFieldEnd()
11330 
    oprot.writeFieldStop()
11331 
    oprot.writeStructEnd()
11332 
 
3431 rajveer 11333 
  def validate(self):
11334 
    return
11335 
 
11336 
 
1113 chandransh 11337 
  def __repr__(self):
11338 
    L = ['%s=%r' % (key, value)
11339 
      for key, value in self.__dict__.iteritems()]
11340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11341 
 
11342 
  def __eq__(self, other):
11343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11344 
 
11345 
  def __ne__(self, other):
11346 
    return not (self == other)
11347 
 
3064 chandransh 11348 
class acceptOrder_result:
1113 chandransh 11349 
  """
11350 
  Attributes:
11351 
   - success
11352 
   - ex
11353 
  """
11354 
 
11355 
  thrift_spec = (
3064 chandransh 11356 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 11357 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11358 
  )
11359 
 
11360 
  def __init__(self, success=None, ex=None,):
11361 
    self.success = success
11362 
    self.ex = ex
11363 
 
11364 
  def read(self, iprot):
11365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11367 
      return
11368 
    iprot.readStructBegin()
11369 
    while True:
11370 
      (fname, ftype, fid) = iprot.readFieldBegin()
11371 
      if ftype == TType.STOP:
11372 
        break
11373 
      if fid == 0:
3064 chandransh 11374 
        if ftype == TType.BOOL:
11375 
          self.success = iprot.readBool();
1113 chandransh 11376 
        else:
11377 
          iprot.skip(ftype)
11378 
      elif fid == 1:
11379 
        if ftype == TType.STRUCT:
11380 
          self.ex = TransactionServiceException()
11381 
          self.ex.read(iprot)
11382 
        else:
11383 
          iprot.skip(ftype)
11384 
      else:
11385 
        iprot.skip(ftype)
11386 
      iprot.readFieldEnd()
11387 
    iprot.readStructEnd()
11388 
 
11389 
  def write(self, oprot):
11390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11392 
      return
3064 chandransh 11393 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 11394 
    if self.success is not None:
3064 chandransh 11395 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11396 
      oprot.writeBool(self.success)
1113 chandransh 11397 
      oprot.writeFieldEnd()
3431 rajveer 11398 
    if self.ex is not None:
1113 chandransh 11399 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11400 
      self.ex.write(oprot)
11401 
      oprot.writeFieldEnd()
11402 
    oprot.writeFieldStop()
11403 
    oprot.writeStructEnd()
11404 
 
3431 rajveer 11405 
  def validate(self):
11406 
    return
11407 
 
11408 
 
1113 chandransh 11409 
  def __repr__(self):
11410 
    L = ['%s=%r' % (key, value)
11411 
      for key, value in self.__dict__.iteritems()]
11412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11413 
 
11414 
  def __eq__(self, other):
11415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11416 
 
11417 
  def __ne__(self, other):
11418 
    return not (self == other)
11419 
 
3064 chandransh 11420 
class addBillingDetails_args:
1135 chandransh 11421 
  """
11422 
  Attributes:
3064 chandransh 11423 
   - orderId
11424 
   - invoice_number
4658 mandeep.dh 11425 
   - serialNumber
4283 anupam.sin 11426 
   - itemNumber
3064 chandransh 11427 
   - billed_by
4264 rajveer 11428 
   - jacketNumber
4283 anupam.sin 11429 
   - billingType
5110 mandeep.dh 11430 
   - fulfilmentWarehouseId
4763 rajveer 11431 
   - authorize
1135 chandransh 11432 
  """
11433 
 
11434 
  thrift_spec = (
11435 
    None, # 0
3064 chandransh 11436 
    (1, TType.I64, 'orderId', None, None, ), # 1
11437 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 11438 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 11439 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
11440 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
11441 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
11442 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 11443 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 11444 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 11445 
  )
11446 
 
5110 mandeep.dh 11447 
  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 11448 
    self.orderId = orderId
11449 
    self.invoice_number = invoice_number
4658 mandeep.dh 11450 
    self.serialNumber = serialNumber
4283 anupam.sin 11451 
    self.itemNumber = itemNumber
3064 chandransh 11452 
    self.billed_by = billed_by
4264 rajveer 11453 
    self.jacketNumber = jacketNumber
4283 anupam.sin 11454 
    self.billingType = billingType
5110 mandeep.dh 11455 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 11456 
    self.authorize = authorize
1135 chandransh 11457 
 
11458 
  def read(self, iprot):
11459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11461 
      return
11462 
    iprot.readStructBegin()
11463 
    while True:
11464 
      (fname, ftype, fid) = iprot.readFieldBegin()
11465 
      if ftype == TType.STOP:
11466 
        break
11467 
      if fid == 1:
11468 
        if ftype == TType.I64:
3064 chandransh 11469 
          self.orderId = iprot.readI64();
1135 chandransh 11470 
        else:
11471 
          iprot.skip(ftype)
11472 
      elif fid == 2:
3064 chandransh 11473 
        if ftype == TType.STRING:
11474 
          self.invoice_number = iprot.readString();
1135 chandransh 11475 
        else:
11476 
          iprot.skip(ftype)
3064 chandransh 11477 
      elif fid == 3:
4658 mandeep.dh 11478 
        if ftype == TType.STRING:
11479 
          self.serialNumber = iprot.readString();
3064 chandransh 11480 
        else:
11481 
          iprot.skip(ftype)
11482 
      elif fid == 4:
11483 
        if ftype == TType.STRING:
11484 
          self.itemNumber = iprot.readString();
11485 
        else:
11486 
          iprot.skip(ftype)
11487 
      elif fid == 5:
11488 
        if ftype == TType.STRING:
4283 anupam.sin 11489 
          self.billed_by = iprot.readString();
3064 chandransh 11490 
        else:
11491 
          iprot.skip(ftype)
11492 
      elif fid == 6:
11493 
        if ftype == TType.I64:
4283 anupam.sin 11494 
          self.jacketNumber = iprot.readI64();
11495 
        else:
11496 
          iprot.skip(ftype)
11497 
      elif fid == 7:
11498 
        if ftype == TType.I64:
3064 chandransh 11499 
          self.billingType = iprot.readI64();
11500 
        else:
11501 
          iprot.skip(ftype)
4283 anupam.sin 11502 
      elif fid == 8:
11503 
        if ftype == TType.I64:
5110 mandeep.dh 11504 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 11505 
        else:
11506 
          iprot.skip(ftype)
4763 rajveer 11507 
      elif fid == 9:
11508 
        if ftype == TType.BOOL:
11509 
          self.authorize = iprot.readBool();
11510 
        else:
11511 
          iprot.skip(ftype)
1246 chandransh 11512 
      else:
11513 
        iprot.skip(ftype)
11514 
      iprot.readFieldEnd()
11515 
    iprot.readStructEnd()
11516 
 
11517 
  def write(self, oprot):
11518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11520 
      return
4283 anupam.sin 11521 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 11522 
    if self.orderId is not None:
3064 chandransh 11523 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11524 
      oprot.writeI64(self.orderId)
1246 chandransh 11525 
      oprot.writeFieldEnd()
4283 anupam.sin 11526 
    if self.invoice_number is not None:
11527 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
11528 
      oprot.writeString(self.invoice_number)
1246 chandransh 11529 
      oprot.writeFieldEnd()
4658 mandeep.dh 11530 
    if self.serialNumber is not None:
11531 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
11532 
      oprot.writeString(self.serialNumber)
3064 chandransh 11533 
      oprot.writeFieldEnd()
3431 rajveer 11534 
    if self.itemNumber is not None:
3064 chandransh 11535 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
11536 
      oprot.writeString(self.itemNumber)
11537 
      oprot.writeFieldEnd()
4283 anupam.sin 11538 
    if self.billed_by is not None:
11539 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
11540 
      oprot.writeString(self.billed_by)
3064 chandransh 11541 
      oprot.writeFieldEnd()
4283 anupam.sin 11542 
    if self.jacketNumber is not None:
11543 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
11544 
      oprot.writeI64(self.jacketNumber)
11545 
      oprot.writeFieldEnd()
3431 rajveer 11546 
    if self.billingType is not None:
4283 anupam.sin 11547 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 11548 
      oprot.writeI64(self.billingType)
11549 
      oprot.writeFieldEnd()
5110 mandeep.dh 11550 
    if self.fulfilmentWarehouseId is not None:
11551 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
11552 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 11553 
      oprot.writeFieldEnd()
4763 rajveer 11554 
    if self.authorize is not None:
11555 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
11556 
      oprot.writeBool(self.authorize)
11557 
      oprot.writeFieldEnd()
1246 chandransh 11558 
    oprot.writeFieldStop()
11559 
    oprot.writeStructEnd()
11560 
 
3431 rajveer 11561 
  def validate(self):
11562 
    return
11563 
 
11564 
 
1246 chandransh 11565 
  def __repr__(self):
11566 
    L = ['%s=%r' % (key, value)
11567 
      for key, value in self.__dict__.iteritems()]
11568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11569 
 
11570 
  def __eq__(self, other):
11571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11572 
 
11573 
  def __ne__(self, other):
11574 
    return not (self == other)
11575 
 
4283 anupam.sin 11576 
class addBillingDetails_result:
1246 chandransh 11577 
  """
11578 
  Attributes:
3064 chandransh 11579 
   - success
1246 chandransh 11580 
   - ex
11581 
  """
11582 
 
11583 
  thrift_spec = (
3064 chandransh 11584 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 11585 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11586 
  )
11587 
 
3064 chandransh 11588 
  def __init__(self, success=None, ex=None,):
11589 
    self.success = success
1246 chandransh 11590 
    self.ex = ex
11591 
 
11592 
  def read(self, iprot):
11593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11595 
      return
11596 
    iprot.readStructBegin()
11597 
    while True:
11598 
      (fname, ftype, fid) = iprot.readFieldBegin()
11599 
      if ftype == TType.STOP:
11600 
        break
3064 chandransh 11601 
      if fid == 0:
11602 
        if ftype == TType.BOOL:
11603 
          self.success = iprot.readBool();
11604 
        else:
11605 
          iprot.skip(ftype)
11606 
      elif fid == 1:
1246 chandransh 11607 
        if ftype == TType.STRUCT:
11608 
          self.ex = TransactionServiceException()
11609 
          self.ex.read(iprot)
11610 
        else:
11611 
          iprot.skip(ftype)
11612 
      else:
11613 
        iprot.skip(ftype)
11614 
      iprot.readFieldEnd()
11615 
    iprot.readStructEnd()
11616 
 
11617 
  def write(self, oprot):
11618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11620 
      return
4283 anupam.sin 11621 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 11622 
    if self.success is not None:
3064 chandransh 11623 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11624 
      oprot.writeBool(self.success)
11625 
      oprot.writeFieldEnd()
3431 rajveer 11626 
    if self.ex is not None:
1246 chandransh 11627 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11628 
      self.ex.write(oprot)
11629 
      oprot.writeFieldEnd()
11630 
    oprot.writeFieldStop()
11631 
    oprot.writeStructEnd()
11632 
 
3431 rajveer 11633 
  def validate(self):
11634 
    return
11635 
 
11636 
 
1246 chandransh 11637 
  def __repr__(self):
11638 
    L = ['%s=%r' % (key, value)
11639 
      for key, value in self.__dict__.iteritems()]
11640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11641 
 
11642 
  def __eq__(self, other):
11643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11644 
 
11645 
  def __ne__(self, other):
11646 
    return not (self == other)
11647 
 
4579 rajveer 11648 
class addInvoiceNumber_args:
11649 
  """
11650 
  Attributes:
11651 
   - orderId
11652 
   - invoiceNumber
4763 rajveer 11653 
   - color
4579 rajveer 11654 
  """
11655 
 
11656 
  thrift_spec = (
11657 
    None, # 0
11658 
    (1, TType.I64, 'orderId', None, None, ), # 1
11659 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 11660 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 11661 
  )
11662 
 
4763 rajveer 11663 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 11664 
    self.orderId = orderId
11665 
    self.invoiceNumber = invoiceNumber
4763 rajveer 11666 
    self.color = color
4579 rajveer 11667 
 
11668 
  def read(self, iprot):
11669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11671 
      return
11672 
    iprot.readStructBegin()
11673 
    while True:
11674 
      (fname, ftype, fid) = iprot.readFieldBegin()
11675 
      if ftype == TType.STOP:
11676 
        break
11677 
      if fid == 1:
11678 
        if ftype == TType.I64:
11679 
          self.orderId = iprot.readI64();
11680 
        else:
11681 
          iprot.skip(ftype)
11682 
      elif fid == 2:
11683 
        if ftype == TType.STRING:
11684 
          self.invoiceNumber = iprot.readString();
11685 
        else:
11686 
          iprot.skip(ftype)
4763 rajveer 11687 
      elif fid == 3:
11688 
        if ftype == TType.STRING:
11689 
          self.color = iprot.readString();
11690 
        else:
11691 
          iprot.skip(ftype)
4579 rajveer 11692 
      else:
11693 
        iprot.skip(ftype)
11694 
      iprot.readFieldEnd()
11695 
    iprot.readStructEnd()
11696 
 
11697 
  def write(self, oprot):
11698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11700 
      return
11701 
    oprot.writeStructBegin('addInvoiceNumber_args')
11702 
    if self.orderId is not None:
11703 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11704 
      oprot.writeI64(self.orderId)
11705 
      oprot.writeFieldEnd()
11706 
    if self.invoiceNumber is not None:
11707 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
11708 
      oprot.writeString(self.invoiceNumber)
11709 
      oprot.writeFieldEnd()
4763 rajveer 11710 
    if self.color is not None:
11711 
      oprot.writeFieldBegin('color', TType.STRING, 3)
11712 
      oprot.writeString(self.color)
11713 
      oprot.writeFieldEnd()
4579 rajveer 11714 
    oprot.writeFieldStop()
11715 
    oprot.writeStructEnd()
11716 
 
11717 
  def validate(self):
11718 
    return
11719 
 
11720 
 
11721 
  def __repr__(self):
11722 
    L = ['%s=%r' % (key, value)
11723 
      for key, value in self.__dict__.iteritems()]
11724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11725 
 
11726 
  def __eq__(self, other):
11727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11728 
 
11729 
  def __ne__(self, other):
11730 
    return not (self == other)
11731 
 
11732 
class addInvoiceNumber_result:
11733 
  """
11734 
  Attributes:
11735 
   - ex
11736 
  """
11737 
 
11738 
  thrift_spec = (
11739 
    None, # 0
11740 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11741 
  )
11742 
 
11743 
  def __init__(self, ex=None,):
11744 
    self.ex = ex
11745 
 
11746 
  def read(self, iprot):
11747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11749 
      return
11750 
    iprot.readStructBegin()
11751 
    while True:
11752 
      (fname, ftype, fid) = iprot.readFieldBegin()
11753 
      if ftype == TType.STOP:
11754 
        break
11755 
      if fid == 1:
11756 
        if ftype == TType.STRUCT:
11757 
          self.ex = TransactionServiceException()
11758 
          self.ex.read(iprot)
11759 
        else:
11760 
          iprot.skip(ftype)
11761 
      else:
11762 
        iprot.skip(ftype)
11763 
      iprot.readFieldEnd()
11764 
    iprot.readStructEnd()
11765 
 
11766 
  def write(self, oprot):
11767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11769 
      return
11770 
    oprot.writeStructBegin('addInvoiceNumber_result')
11771 
    if self.ex is not None:
11772 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11773 
      self.ex.write(oprot)
11774 
      oprot.writeFieldEnd()
11775 
    oprot.writeFieldStop()
11776 
    oprot.writeStructEnd()
11777 
 
11778 
  def validate(self):
11779 
    return
11780 
 
11781 
 
11782 
  def __repr__(self):
11783 
    L = ['%s=%r' % (key, value)
11784 
      for key, value in self.__dict__.iteritems()]
11785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11786 
 
11787 
  def __eq__(self, other):
11788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11789 
 
11790 
  def __ne__(self, other):
11791 
    return not (self == other)
11792 
 
4910 phani.kuma 11793 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 11794 
  """
11795 
  Attributes:
3064 chandransh 11796 
   - warehouseId
1408 ankur.sing 11797 
   - providerId
3064 chandransh 11798 
   - cod
4910 phani.kuma 11799 
   - orderIds
1408 ankur.sing 11800 
  """
11801 
 
11802 
  thrift_spec = (
11803 
    None, # 0
3064 chandransh 11804 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11805 
    (2, TType.I64, 'providerId', None, None, ), # 2
11806 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 11807 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 11808 
  )
11809 
 
4910 phani.kuma 11810 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 11811 
    self.warehouseId = warehouseId
1408 ankur.sing 11812 
    self.providerId = providerId
3064 chandransh 11813 
    self.cod = cod
4910 phani.kuma 11814 
    self.orderIds = orderIds
1408 ankur.sing 11815 
 
11816 
  def read(self, iprot):
11817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11819 
      return
11820 
    iprot.readStructBegin()
11821 
    while True:
11822 
      (fname, ftype, fid) = iprot.readFieldBegin()
11823 
      if ftype == TType.STOP:
11824 
        break
11825 
      if fid == 1:
11826 
        if ftype == TType.I64:
3064 chandransh 11827 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 11828 
        else:
11829 
          iprot.skip(ftype)
11830 
      elif fid == 2:
11831 
        if ftype == TType.I64:
3064 chandransh 11832 
          self.providerId = iprot.readI64();
1408 ankur.sing 11833 
        else:
11834 
          iprot.skip(ftype)
3064 chandransh 11835 
      elif fid == 3:
11836 
        if ftype == TType.BOOL:
11837 
          self.cod = iprot.readBool();
11838 
        else:
11839 
          iprot.skip(ftype)
4910 phani.kuma 11840 
      elif fid == 4:
11841 
        if ftype == TType.LIST:
11842 
          self.orderIds = []
5031 varun.gupt 11843 
          (_etype213, _size210) = iprot.readListBegin()
11844 
          for _i214 in xrange(_size210):
11845 
            _elem215 = iprot.readI64();
11846 
            self.orderIds.append(_elem215)
4910 phani.kuma 11847 
          iprot.readListEnd()
11848 
        else:
11849 
          iprot.skip(ftype)
1408 ankur.sing 11850 
      else:
11851 
        iprot.skip(ftype)
11852 
      iprot.readFieldEnd()
11853 
    iprot.readStructEnd()
11854 
 
11855 
  def write(self, oprot):
11856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11858 
      return
4910 phani.kuma 11859 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 11860 
    if self.warehouseId is not None:
3064 chandransh 11861 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11862 
      oprot.writeI64(self.warehouseId)
11863 
      oprot.writeFieldEnd()
3431 rajveer 11864 
    if self.providerId is not None:
3064 chandransh 11865 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 11866 
      oprot.writeI64(self.providerId)
11867 
      oprot.writeFieldEnd()
3431 rajveer 11868 
    if self.cod is not None:
3064 chandransh 11869 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
11870 
      oprot.writeBool(self.cod)
1408 ankur.sing 11871 
      oprot.writeFieldEnd()
4910 phani.kuma 11872 
    if self.orderIds is not None:
11873 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
11874 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5031 varun.gupt 11875 
      for iter216 in self.orderIds:
11876 
        oprot.writeI64(iter216)
4910 phani.kuma 11877 
      oprot.writeListEnd()
11878 
      oprot.writeFieldEnd()
1408 ankur.sing 11879 
    oprot.writeFieldStop()
11880 
    oprot.writeStructEnd()
11881 
 
3431 rajveer 11882 
  def validate(self):
11883 
    return
11884 
 
11885 
 
1408 ankur.sing 11886 
  def __repr__(self):
11887 
    L = ['%s=%r' % (key, value)
11888 
      for key, value in self.__dict__.iteritems()]
11889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11890 
 
11891 
  def __eq__(self, other):
11892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11893 
 
11894 
  def __ne__(self, other):
11895 
    return not (self == other)
11896 
 
4910 phani.kuma 11897 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 11898 
  """
11899 
  Attributes:
11900 
   - success
3064 chandransh 11901 
   - ex
1408 ankur.sing 11902 
  """
11903 
 
11904 
  thrift_spec = (
3064 chandransh 11905 
    (0, TType.BOOL, 'success', None, None, ), # 0
11906 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 11907 
  )
11908 
 
3064 chandransh 11909 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 11910 
    self.success = success
3064 chandransh 11911 
    self.ex = ex
1408 ankur.sing 11912 
 
11913 
  def read(self, iprot):
11914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11916 
      return
11917 
    iprot.readStructBegin()
11918 
    while True:
11919 
      (fname, ftype, fid) = iprot.readFieldBegin()
11920 
      if ftype == TType.STOP:
11921 
        break
11922 
      if fid == 0:
3064 chandransh 11923 
        if ftype == TType.BOOL:
11924 
          self.success = iprot.readBool();
1408 ankur.sing 11925 
        else:
11926 
          iprot.skip(ftype)
3064 chandransh 11927 
      elif fid == 1:
11928 
        if ftype == TType.STRUCT:
11929 
          self.ex = TransactionServiceException()
11930 
          self.ex.read(iprot)
11931 
        else:
11932 
          iprot.skip(ftype)
1408 ankur.sing 11933 
      else:
11934 
        iprot.skip(ftype)
11935 
      iprot.readFieldEnd()
11936 
    iprot.readStructEnd()
11937 
 
11938 
  def write(self, oprot):
11939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11941 
      return
4910 phani.kuma 11942 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 11943 
    if self.success is not None:
3064 chandransh 11944 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11945 
      oprot.writeBool(self.success)
1408 ankur.sing 11946 
      oprot.writeFieldEnd()
3431 rajveer 11947 
    if self.ex is not None:
3064 chandransh 11948 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11949 
      self.ex.write(oprot)
11950 
      oprot.writeFieldEnd()
1408 ankur.sing 11951 
    oprot.writeFieldStop()
11952 
    oprot.writeStructEnd()
11953 
 
3431 rajveer 11954 
  def validate(self):
11955 
    return
11956 
 
11957 
 
1408 ankur.sing 11958 
  def __repr__(self):
11959 
    L = ['%s=%r' % (key, value)
11960 
      for key, value in self.__dict__.iteritems()]
11961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11962 
 
11963 
  def __eq__(self, other):
11964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11965 
 
11966 
  def __ne__(self, other):
11967 
    return not (self == other)
11968 
 
4910 phani.kuma 11969 
class markOrdersAsPickedUp_args:
4410 rajveer 11970 
  """
11971 
  Attributes:
11972 
   - providerId
4910 phani.kuma 11973 
   - pickupDetails
4410 rajveer 11974 
  """
11975 
 
11976 
  thrift_spec = (
11977 
    None, # 0
4910 phani.kuma 11978 
    (1, TType.I64, 'providerId', None, None, ), # 1
11979 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 11980 
  )
11981 
 
4910 phani.kuma 11982 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 11983 
    self.providerId = providerId
4910 phani.kuma 11984 
    self.pickupDetails = pickupDetails
4410 rajveer 11985 
 
11986 
  def read(self, iprot):
11987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11989 
      return
11990 
    iprot.readStructBegin()
11991 
    while True:
11992 
      (fname, ftype, fid) = iprot.readFieldBegin()
11993 
      if ftype == TType.STOP:
11994 
        break
11995 
      if fid == 1:
11996 
        if ftype == TType.I64:
4910 phani.kuma 11997 
          self.providerId = iprot.readI64();
4410 rajveer 11998 
        else:
11999 
          iprot.skip(ftype)
12000 
      elif fid == 2:
4910 phani.kuma 12001 
        if ftype == TType.MAP:
12002 
          self.pickupDetails = {}
5031 varun.gupt 12003 
          (_ktype218, _vtype219, _size217 ) = iprot.readMapBegin()
12004 
          for _i221 in xrange(_size217):
12005 
            _key222 = iprot.readString();
12006 
            _val223 = iprot.readString();
12007 
            self.pickupDetails[_key222] = _val223
4910 phani.kuma 12008 
          iprot.readMapEnd()
4410 rajveer 12009 
        else:
12010 
          iprot.skip(ftype)
12011 
      else:
12012 
        iprot.skip(ftype)
12013 
      iprot.readFieldEnd()
12014 
    iprot.readStructEnd()
12015 
 
12016 
  def write(self, oprot):
12017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12019 
      return
4910 phani.kuma 12020 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 12021 
    if self.providerId is not None:
4910 phani.kuma 12022 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 12023 
      oprot.writeI64(self.providerId)
12024 
      oprot.writeFieldEnd()
4910 phani.kuma 12025 
    if self.pickupDetails is not None:
12026 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
12027 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 12028 
      for kiter224,viter225 in self.pickupDetails.items():
12029 
        oprot.writeString(kiter224)
12030 
        oprot.writeString(viter225)
4910 phani.kuma 12031 
      oprot.writeMapEnd()
4410 rajveer 12032 
      oprot.writeFieldEnd()
12033 
    oprot.writeFieldStop()
12034 
    oprot.writeStructEnd()
12035 
 
12036 
  def validate(self):
12037 
    return
12038 
 
12039 
 
12040 
  def __repr__(self):
12041 
    L = ['%s=%r' % (key, value)
12042 
      for key, value in self.__dict__.iteritems()]
12043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12044 
 
12045 
  def __eq__(self, other):
12046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12047 
 
12048 
  def __ne__(self, other):
12049 
    return not (self == other)
12050 
 
4910 phani.kuma 12051 
class markOrdersAsPickedUp_result:
4410 rajveer 12052 
  """
12053 
  Attributes:
12054 
   - ex
12055 
  """
12056 
 
12057 
  thrift_spec = (
4910 phani.kuma 12058 
    None, # 0
4410 rajveer 12059 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12060 
  )
12061 
 
4910 phani.kuma 12062 
  def __init__(self, ex=None,):
4410 rajveer 12063 
    self.ex = ex
12064 
 
12065 
  def read(self, iprot):
12066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12068 
      return
12069 
    iprot.readStructBegin()
12070 
    while True:
12071 
      (fname, ftype, fid) = iprot.readFieldBegin()
12072 
      if ftype == TType.STOP:
12073 
        break
4910 phani.kuma 12074 
      if fid == 1:
4410 rajveer 12075 
        if ftype == TType.STRUCT:
12076 
          self.ex = TransactionServiceException()
12077 
          self.ex.read(iprot)
12078 
        else:
12079 
          iprot.skip(ftype)
12080 
      else:
12081 
        iprot.skip(ftype)
12082 
      iprot.readFieldEnd()
12083 
    iprot.readStructEnd()
12084 
 
12085 
  def write(self, oprot):
12086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12088 
      return
4910 phani.kuma 12089 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 12090 
    if self.ex is not None:
12091 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12092 
      self.ex.write(oprot)
12093 
      oprot.writeFieldEnd()
12094 
    oprot.writeFieldStop()
12095 
    oprot.writeStructEnd()
12096 
 
12097 
  def validate(self):
12098 
    return
12099 
 
12100 
 
12101 
  def __repr__(self):
12102 
    L = ['%s=%r' % (key, value)
12103 
      for key, value in self.__dict__.iteritems()]
12104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12105 
 
12106 
  def __eq__(self, other):
12107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12108 
 
12109 
  def __ne__(self, other):
12110 
    return not (self == other)
12111 
 
4910 phani.kuma 12112 
class getOrdersNotPickedUp_args:
304 ashish 12113 
  """
12114 
  Attributes:
3064 chandransh 12115 
   - providerId
304 ashish 12116 
  """
94 ashish 12117 
 
304 ashish 12118 
  thrift_spec = (
12119 
    None, # 0
3064 chandransh 12120 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 12121 
  )
12122 
 
4910 phani.kuma 12123 
  def __init__(self, providerId=None,):
3064 chandransh 12124 
    self.providerId = providerId
304 ashish 12125 
 
12126 
  def read(self, iprot):
12127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12129 
      return
12130 
    iprot.readStructBegin()
12131 
    while True:
12132 
      (fname, ftype, fid) = iprot.readFieldBegin()
12133 
      if ftype == TType.STOP:
12134 
        break
12135 
      if fid == 1:
12136 
        if ftype == TType.I64:
3064 chandransh 12137 
          self.providerId = iprot.readI64();
304 ashish 12138 
        else:
12139 
          iprot.skip(ftype)
12140 
      else:
12141 
        iprot.skip(ftype)
12142 
      iprot.readFieldEnd()
12143 
    iprot.readStructEnd()
12144 
 
12145 
  def write(self, oprot):
12146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12148 
      return
4910 phani.kuma 12149 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 12150 
    if self.providerId is not None:
3064 chandransh 12151 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12152 
      oprot.writeI64(self.providerId)
304 ashish 12153 
      oprot.writeFieldEnd()
12154 
    oprot.writeFieldStop()
12155 
    oprot.writeStructEnd()
12156 
 
3431 rajveer 12157 
  def validate(self):
12158 
    return
12159 
 
12160 
 
304 ashish 12161 
  def __repr__(self):
12162 
    L = ['%s=%r' % (key, value)
12163 
      for key, value in self.__dict__.iteritems()]
12164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12165 
 
12166 
  def __eq__(self, other):
12167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12168 
 
12169 
  def __ne__(self, other):
12170 
    return not (self == other)
12171 
 
4910 phani.kuma 12172 
class getOrdersNotPickedUp_result:
304 ashish 12173 
  """
12174 
  Attributes:
12175 
   - success
12176 
  """
12177 
 
12178 
  thrift_spec = (
3064 chandransh 12179 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 12180 
  )
12181 
 
4910 phani.kuma 12182 
  def __init__(self, success=None,):
304 ashish 12183 
    self.success = success
12184 
 
12185 
  def read(self, iprot):
12186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12188 
      return
12189 
    iprot.readStructBegin()
12190 
    while True:
12191 
      (fname, ftype, fid) = iprot.readFieldBegin()
12192 
      if ftype == TType.STOP:
12193 
        break
12194 
      if fid == 0:
12195 
        if ftype == TType.LIST:
12196 
          self.success = []
5031 varun.gupt 12197 
          (_etype229, _size226) = iprot.readListBegin()
12198 
          for _i230 in xrange(_size226):
12199 
            _elem231 = Order()
12200 
            _elem231.read(iprot)
12201 
            self.success.append(_elem231)
304 ashish 12202 
          iprot.readListEnd()
12203 
        else:
12204 
          iprot.skip(ftype)
12205 
      else:
12206 
        iprot.skip(ftype)
12207 
      iprot.readFieldEnd()
12208 
    iprot.readStructEnd()
12209 
 
12210 
  def write(self, oprot):
12211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12213 
      return
4910 phani.kuma 12214 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 12215 
    if self.success is not None:
304 ashish 12216 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12217 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12218 
      for iter232 in self.success:
12219 
        iter232.write(oprot)
304 ashish 12220 
      oprot.writeListEnd()
12221 
      oprot.writeFieldEnd()
12222 
    oprot.writeFieldStop()
12223 
    oprot.writeStructEnd()
12224 
 
3431 rajveer 12225 
  def validate(self):
12226 
    return
12227 
 
12228 
 
304 ashish 12229 
  def __repr__(self):
12230 
    L = ['%s=%r' % (key, value)
12231 
      for key, value in self.__dict__.iteritems()]
12232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12233 
 
12234 
  def __eq__(self, other):
12235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12236 
 
12237 
  def __ne__(self, other):
12238 
    return not (self == other)
12239 
 
3064 chandransh 12240 
class markOrdersAsDelivered_args:
304 ashish 12241 
  """
12242 
  Attributes:
3064 chandransh 12243 
   - providerId
12244 
   - deliveredOrders
304 ashish 12245 
  """
12246 
 
12247 
  thrift_spec = (
12248 
    None, # 0
3064 chandransh 12249 
    (1, TType.I64, 'providerId', None, None, ), # 1
12250 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 12251 
  )
12252 
 
3064 chandransh 12253 
  def __init__(self, providerId=None, deliveredOrders=None,):
12254 
    self.providerId = providerId
12255 
    self.deliveredOrders = deliveredOrders
304 ashish 12256 
 
12257 
  def read(self, iprot):
12258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12260 
      return
12261 
    iprot.readStructBegin()
12262 
    while True:
12263 
      (fname, ftype, fid) = iprot.readFieldBegin()
12264 
      if ftype == TType.STOP:
12265 
        break
12266 
      if fid == 1:
12267 
        if ftype == TType.I64:
3064 chandransh 12268 
          self.providerId = iprot.readI64();
304 ashish 12269 
        else:
12270 
          iprot.skip(ftype)
12271 
      elif fid == 2:
3064 chandransh 12272 
        if ftype == TType.MAP:
12273 
          self.deliveredOrders = {}
5031 varun.gupt 12274 
          (_ktype234, _vtype235, _size233 ) = iprot.readMapBegin()
12275 
          for _i237 in xrange(_size233):
12276 
            _key238 = iprot.readString();
12277 
            _val239 = iprot.readString();
12278 
            self.deliveredOrders[_key238] = _val239
3064 chandransh 12279 
          iprot.readMapEnd()
304 ashish 12280 
        else:
12281 
          iprot.skip(ftype)
12282 
      else:
12283 
        iprot.skip(ftype)
12284 
      iprot.readFieldEnd()
12285 
    iprot.readStructEnd()
12286 
 
12287 
  def write(self, oprot):
12288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12290 
      return
3064 chandransh 12291 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 12292 
    if self.providerId is not None:
3064 chandransh 12293 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12294 
      oprot.writeI64(self.providerId)
304 ashish 12295 
      oprot.writeFieldEnd()
3431 rajveer 12296 
    if self.deliveredOrders is not None:
3064 chandransh 12297 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
12298 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
5031 varun.gupt 12299 
      for kiter240,viter241 in self.deliveredOrders.items():
12300 
        oprot.writeString(kiter240)
12301 
        oprot.writeString(viter241)
3064 chandransh 12302 
      oprot.writeMapEnd()
304 ashish 12303 
      oprot.writeFieldEnd()
12304 
    oprot.writeFieldStop()
12305 
    oprot.writeStructEnd()
12306 
 
3431 rajveer 12307 
  def validate(self):
12308 
    return
12309 
 
12310 
 
304 ashish 12311 
  def __repr__(self):
12312 
    L = ['%s=%r' % (key, value)
12313 
      for key, value in self.__dict__.iteritems()]
12314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12315 
 
12316 
  def __eq__(self, other):
12317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12318 
 
12319 
  def __ne__(self, other):
12320 
    return not (self == other)
12321 
 
3064 chandransh 12322 
class markOrdersAsDelivered_result:
12323 
  """
12324 
  Attributes:
12325 
   - ex
12326 
  """
304 ashish 12327 
 
12328 
  thrift_spec = (
3064 chandransh 12329 
    None, # 0
12330 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 12331 
  )
12332 
 
3064 chandransh 12333 
  def __init__(self, ex=None,):
12334 
    self.ex = ex
304 ashish 12335 
 
1596 ankur.sing 12336 
  def read(self, iprot):
12337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12339 
      return
12340 
    iprot.readStructBegin()
12341 
    while True:
12342 
      (fname, ftype, fid) = iprot.readFieldBegin()
12343 
      if ftype == TType.STOP:
12344 
        break
3064 chandransh 12345 
      if fid == 1:
12346 
        if ftype == TType.STRUCT:
12347 
          self.ex = TransactionServiceException()
12348 
          self.ex.read(iprot)
12349 
        else:
12350 
          iprot.skip(ftype)
1596 ankur.sing 12351 
      else:
12352 
        iprot.skip(ftype)
12353 
      iprot.readFieldEnd()
12354 
    iprot.readStructEnd()
12355 
 
12356 
  def write(self, oprot):
12357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12359 
      return
3064 chandransh 12360 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 12361 
    if self.ex is not None:
3064 chandransh 12362 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12363 
      self.ex.write(oprot)
12364 
      oprot.writeFieldEnd()
1596 ankur.sing 12365 
    oprot.writeFieldStop()
12366 
    oprot.writeStructEnd()
12367 
 
3431 rajveer 12368 
  def validate(self):
12369 
    return
12370 
 
12371 
 
1596 ankur.sing 12372 
  def __repr__(self):
12373 
    L = ['%s=%r' % (key, value)
12374 
      for key, value in self.__dict__.iteritems()]
12375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12376 
 
12377 
  def __eq__(self, other):
12378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12379 
 
12380 
  def __ne__(self, other):
12381 
    return not (self == other)
12382 
 
4910 phani.kuma 12383 
class markAsRTOrders_args:
1596 ankur.sing 12384 
  """
12385 
  Attributes:
3064 chandransh 12386 
   - providerId
12387 
   - returnedOrders
1596 ankur.sing 12388 
  """
12389 
 
12390 
  thrift_spec = (
3064 chandransh 12391 
    None, # 0
12392 
    (1, TType.I64, 'providerId', None, None, ), # 1
12393 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 12394 
  )
12395 
 
3064 chandransh 12396 
  def __init__(self, providerId=None, returnedOrders=None,):
12397 
    self.providerId = providerId
12398 
    self.returnedOrders = returnedOrders
1596 ankur.sing 12399 
 
12400 
  def read(self, iprot):
12401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12403 
      return
12404 
    iprot.readStructBegin()
12405 
    while True:
12406 
      (fname, ftype, fid) = iprot.readFieldBegin()
12407 
      if ftype == TType.STOP:
12408 
        break
3064 chandransh 12409 
      if fid == 1:
1596 ankur.sing 12410 
        if ftype == TType.I64:
3064 chandransh 12411 
          self.providerId = iprot.readI64();
1596 ankur.sing 12412 
        else:
12413 
          iprot.skip(ftype)
3064 chandransh 12414 
      elif fid == 2:
12415 
        if ftype == TType.MAP:
12416 
          self.returnedOrders = {}
5031 varun.gupt 12417 
          (_ktype243, _vtype244, _size242 ) = iprot.readMapBegin()
12418 
          for _i246 in xrange(_size242):
12419 
            _key247 = iprot.readString();
12420 
            _val248 = iprot.readString();
12421 
            self.returnedOrders[_key247] = _val248
3064 chandransh 12422 
          iprot.readMapEnd()
12423 
        else:
12424 
          iprot.skip(ftype)
1596 ankur.sing 12425 
      else:
12426 
        iprot.skip(ftype)
12427 
      iprot.readFieldEnd()
12428 
    iprot.readStructEnd()
12429 
 
12430 
  def write(self, oprot):
12431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12433 
      return
4910 phani.kuma 12434 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 12435 
    if self.providerId is not None:
3064 chandransh 12436 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12437 
      oprot.writeI64(self.providerId)
1596 ankur.sing 12438 
      oprot.writeFieldEnd()
3431 rajveer 12439 
    if self.returnedOrders is not None:
3064 chandransh 12440 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
12441 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
5031 varun.gupt 12442 
      for kiter249,viter250 in self.returnedOrders.items():
12443 
        oprot.writeString(kiter249)
12444 
        oprot.writeString(viter250)
3064 chandransh 12445 
      oprot.writeMapEnd()
12446 
      oprot.writeFieldEnd()
1596 ankur.sing 12447 
    oprot.writeFieldStop()
12448 
    oprot.writeStructEnd()
12449 
 
3431 rajveer 12450 
  def validate(self):
12451 
    return
12452 
 
12453 
 
1596 ankur.sing 12454 
  def __repr__(self):
12455 
    L = ['%s=%r' % (key, value)
12456 
      for key, value in self.__dict__.iteritems()]
12457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12458 
 
12459 
  def __eq__(self, other):
12460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12461 
 
12462 
  def __ne__(self, other):
12463 
    return not (self == other)
12464 
 
4910 phani.kuma 12465 
class markAsRTOrders_result:
3064 chandransh 12466 
  """
12467 
  Attributes:
12468 
   - ex
12469 
  """
1596 ankur.sing 12470 
 
1627 ankur.sing 12471 
  thrift_spec = (
3064 chandransh 12472 
    None, # 0
12473 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12474 
  )
12475 
 
3064 chandransh 12476 
  def __init__(self, ex=None,):
12477 
    self.ex = ex
12478 
 
1627 ankur.sing 12479 
  def read(self, iprot):
12480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12482 
      return
12483 
    iprot.readStructBegin()
12484 
    while True:
12485 
      (fname, ftype, fid) = iprot.readFieldBegin()
12486 
      if ftype == TType.STOP:
12487 
        break
3064 chandransh 12488 
      if fid == 1:
12489 
        if ftype == TType.STRUCT:
12490 
          self.ex = TransactionServiceException()
12491 
          self.ex.read(iprot)
12492 
        else:
12493 
          iprot.skip(ftype)
1627 ankur.sing 12494 
      else:
12495 
        iprot.skip(ftype)
12496 
      iprot.readFieldEnd()
12497 
    iprot.readStructEnd()
12498 
 
12499 
  def write(self, oprot):
12500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12502 
      return
4910 phani.kuma 12503 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 12504 
    if self.ex is not None:
3064 chandransh 12505 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12506 
      self.ex.write(oprot)
12507 
      oprot.writeFieldEnd()
1627 ankur.sing 12508 
    oprot.writeFieldStop()
12509 
    oprot.writeStructEnd()
12510 
 
3431 rajveer 12511 
  def validate(self):
12512 
    return
12513 
 
12514 
 
1627 ankur.sing 12515 
  def __repr__(self):
12516 
    L = ['%s=%r' % (key, value)
12517 
      for key, value in self.__dict__.iteritems()]
12518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12519 
 
12520 
  def __eq__(self, other):
12521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12522 
 
12523 
  def __ne__(self, other):
12524 
    return not (self == other)
12525 
 
4910 phani.kuma 12526 
class getRTOrders_args:
12527 
  """
12528 
  Attributes:
12529 
   - providerId
12530 
  """
12531 
 
12532 
  thrift_spec = (
12533 
    None, # 0
12534 
    (1, TType.I64, 'providerId', None, None, ), # 1
12535 
  )
12536 
 
12537 
  def __init__(self, providerId=None,):
12538 
    self.providerId = providerId
12539 
 
12540 
  def read(self, iprot):
12541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12543 
      return
12544 
    iprot.readStructBegin()
12545 
    while True:
12546 
      (fname, ftype, fid) = iprot.readFieldBegin()
12547 
      if ftype == TType.STOP:
12548 
        break
12549 
      if fid == 1:
12550 
        if ftype == TType.I64:
12551 
          self.providerId = iprot.readI64();
12552 
        else:
12553 
          iprot.skip(ftype)
12554 
      else:
12555 
        iprot.skip(ftype)
12556 
      iprot.readFieldEnd()
12557 
    iprot.readStructEnd()
12558 
 
12559 
  def write(self, oprot):
12560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12562 
      return
12563 
    oprot.writeStructBegin('getRTOrders_args')
12564 
    if self.providerId is not None:
12565 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12566 
      oprot.writeI64(self.providerId)
12567 
      oprot.writeFieldEnd()
12568 
    oprot.writeFieldStop()
12569 
    oprot.writeStructEnd()
12570 
 
12571 
  def validate(self):
12572 
    return
12573 
 
12574 
 
12575 
  def __repr__(self):
12576 
    L = ['%s=%r' % (key, value)
12577 
      for key, value in self.__dict__.iteritems()]
12578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12579 
 
12580 
  def __eq__(self, other):
12581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12582 
 
12583 
  def __ne__(self, other):
12584 
    return not (self == other)
12585 
 
12586 
class getRTOrders_result:
12587 
  """
12588 
  Attributes:
12589 
   - success
12590 
  """
12591 
 
12592 
  thrift_spec = (
12593 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12594 
  )
12595 
 
12596 
  def __init__(self, success=None,):
12597 
    self.success = success
12598 
 
12599 
  def read(self, iprot):
12600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12602 
      return
12603 
    iprot.readStructBegin()
12604 
    while True:
12605 
      (fname, ftype, fid) = iprot.readFieldBegin()
12606 
      if ftype == TType.STOP:
12607 
        break
12608 
      if fid == 0:
12609 
        if ftype == TType.LIST:
12610 
          self.success = []
5031 varun.gupt 12611 
          (_etype254, _size251) = iprot.readListBegin()
12612 
          for _i255 in xrange(_size251):
12613 
            _elem256 = Order()
12614 
            _elem256.read(iprot)
12615 
            self.success.append(_elem256)
4910 phani.kuma 12616 
          iprot.readListEnd()
12617 
        else:
12618 
          iprot.skip(ftype)
12619 
      else:
12620 
        iprot.skip(ftype)
12621 
      iprot.readFieldEnd()
12622 
    iprot.readStructEnd()
12623 
 
12624 
  def write(self, oprot):
12625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12627 
      return
12628 
    oprot.writeStructBegin('getRTOrders_result')
12629 
    if self.success is not None:
12630 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12631 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12632 
      for iter257 in self.success:
12633 
        iter257.write(oprot)
4910 phani.kuma 12634 
      oprot.writeListEnd()
12635 
      oprot.writeFieldEnd()
12636 
    oprot.writeFieldStop()
12637 
    oprot.writeStructEnd()
12638 
 
12639 
  def validate(self):
12640 
    return
12641 
 
12642 
 
12643 
  def __repr__(self):
12644 
    L = ['%s=%r' % (key, value)
12645 
      for key, value in self.__dict__.iteritems()]
12646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12647 
 
12648 
  def __eq__(self, other):
12649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12650 
 
12651 
  def __ne__(self, other):
12652 
    return not (self == other)
12653 
 
3064 chandransh 12654 
class updateNonDeliveryReason_args:
1627 ankur.sing 12655 
  """
12656 
  Attributes:
3064 chandransh 12657 
   - providerId
12658 
   - undeliveredOrders
1627 ankur.sing 12659 
  """
12660 
 
12661 
  thrift_spec = (
3064 chandransh 12662 
    None, # 0
12663 
    (1, TType.I64, 'providerId', None, None, ), # 1
12664 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 12665 
  )
12666 
 
3064 chandransh 12667 
  def __init__(self, providerId=None, undeliveredOrders=None,):
12668 
    self.providerId = providerId
12669 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 12670 
 
12671 
  def read(self, iprot):
12672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12674 
      return
12675 
    iprot.readStructBegin()
12676 
    while True:
12677 
      (fname, ftype, fid) = iprot.readFieldBegin()
12678 
      if ftype == TType.STOP:
12679 
        break
3064 chandransh 12680 
      if fid == 1:
1627 ankur.sing 12681 
        if ftype == TType.I64:
3064 chandransh 12682 
          self.providerId = iprot.readI64();
1627 ankur.sing 12683 
        else:
12684 
          iprot.skip(ftype)
3064 chandransh 12685 
      elif fid == 2:
12686 
        if ftype == TType.MAP:
12687 
          self.undeliveredOrders = {}
5031 varun.gupt 12688 
          (_ktype259, _vtype260, _size258 ) = iprot.readMapBegin()
12689 
          for _i262 in xrange(_size258):
12690 
            _key263 = iprot.readString();
12691 
            _val264 = iprot.readString();
12692 
            self.undeliveredOrders[_key263] = _val264
3064 chandransh 12693 
          iprot.readMapEnd()
12694 
        else:
12695 
          iprot.skip(ftype)
1627 ankur.sing 12696 
      else:
12697 
        iprot.skip(ftype)
12698 
      iprot.readFieldEnd()
12699 
    iprot.readStructEnd()
12700 
 
12701 
  def write(self, oprot):
12702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12704 
      return
3064 chandransh 12705 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 12706 
    if self.providerId is not None:
3064 chandransh 12707 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12708 
      oprot.writeI64(self.providerId)
1627 ankur.sing 12709 
      oprot.writeFieldEnd()
3431 rajveer 12710 
    if self.undeliveredOrders is not None:
3064 chandransh 12711 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
12712 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
5031 varun.gupt 12713 
      for kiter265,viter266 in self.undeliveredOrders.items():
12714 
        oprot.writeString(kiter265)
12715 
        oprot.writeString(viter266)
3064 chandransh 12716 
      oprot.writeMapEnd()
12717 
      oprot.writeFieldEnd()
1627 ankur.sing 12718 
    oprot.writeFieldStop()
12719 
    oprot.writeStructEnd()
12720 
 
3431 rajveer 12721 
  def validate(self):
12722 
    return
12723 
 
12724 
 
1627 ankur.sing 12725 
  def __repr__(self):
12726 
    L = ['%s=%r' % (key, value)
12727 
      for key, value in self.__dict__.iteritems()]
12728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12729 
 
12730 
  def __eq__(self, other):
12731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12732 
 
12733 
  def __ne__(self, other):
12734 
    return not (self == other)
12735 
 
3064 chandransh 12736 
class updateNonDeliveryReason_result:
1627 ankur.sing 12737 
  """
12738 
  Attributes:
3064 chandransh 12739 
   - ex
1627 ankur.sing 12740 
  """
12741 
 
12742 
  thrift_spec = (
4910 phani.kuma 12743 
    None, # 0
3064 chandransh 12744 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12745 
  )
12746 
 
4910 phani.kuma 12747 
  def __init__(self, ex=None,):
3064 chandransh 12748 
    self.ex = ex
1627 ankur.sing 12749 
 
12750 
  def read(self, iprot):
12751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12753 
      return
12754 
    iprot.readStructBegin()
12755 
    while True:
12756 
      (fname, ftype, fid) = iprot.readFieldBegin()
12757 
      if ftype == TType.STOP:
12758 
        break
4910 phani.kuma 12759 
      if fid == 1:
12760 
        if ftype == TType.STRUCT:
12761 
          self.ex = TransactionServiceException()
12762 
          self.ex.read(iprot)
12763 
        else:
12764 
          iprot.skip(ftype)
12765 
      else:
12766 
        iprot.skip(ftype)
12767 
      iprot.readFieldEnd()
12768 
    iprot.readStructEnd()
12769 
 
12770 
  def write(self, oprot):
12771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12773 
      return
12774 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
12775 
    if self.ex is not None:
12776 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12777 
      self.ex.write(oprot)
12778 
      oprot.writeFieldEnd()
12779 
    oprot.writeFieldStop()
12780 
    oprot.writeStructEnd()
12781 
 
12782 
  def validate(self):
12783 
    return
12784 
 
12785 
 
12786 
  def __repr__(self):
12787 
    L = ['%s=%r' % (key, value)
12788 
      for key, value in self.__dict__.iteritems()]
12789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12790 
 
12791 
  def __eq__(self, other):
12792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12793 
 
12794 
  def __ne__(self, other):
12795 
    return not (self == other)
12796 
 
12797 
class getNonDeliveredOrdersbyCourier_args:
12798 
  """
12799 
  Attributes:
12800 
   - providerId
12801 
  """
12802 
 
12803 
  thrift_spec = (
12804 
    None, # 0
12805 
    (1, TType.I64, 'providerId', None, None, ), # 1
12806 
  )
12807 
 
12808 
  def __init__(self, providerId=None,):
12809 
    self.providerId = providerId
12810 
 
12811 
  def read(self, iprot):
12812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12814 
      return
12815 
    iprot.readStructBegin()
12816 
    while True:
12817 
      (fname, ftype, fid) = iprot.readFieldBegin()
12818 
      if ftype == TType.STOP:
12819 
        break
12820 
      if fid == 1:
12821 
        if ftype == TType.I64:
12822 
          self.providerId = iprot.readI64();
12823 
        else:
12824 
          iprot.skip(ftype)
12825 
      else:
12826 
        iprot.skip(ftype)
12827 
      iprot.readFieldEnd()
12828 
    iprot.readStructEnd()
12829 
 
12830 
  def write(self, oprot):
12831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12833 
      return
12834 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
12835 
    if self.providerId is not None:
12836 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12837 
      oprot.writeI64(self.providerId)
12838 
      oprot.writeFieldEnd()
12839 
    oprot.writeFieldStop()
12840 
    oprot.writeStructEnd()
12841 
 
12842 
  def validate(self):
12843 
    return
12844 
 
12845 
 
12846 
  def __repr__(self):
12847 
    L = ['%s=%r' % (key, value)
12848 
      for key, value in self.__dict__.iteritems()]
12849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12850 
 
12851 
  def __eq__(self, other):
12852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12853 
 
12854 
  def __ne__(self, other):
12855 
    return not (self == other)
12856 
 
12857 
class getNonDeliveredOrdersbyCourier_result:
12858 
  """
12859 
  Attributes:
12860 
   - success
12861 
  """
12862 
 
12863 
  thrift_spec = (
12864 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12865 
  )
12866 
 
12867 
  def __init__(self, success=None,):
12868 
    self.success = success
12869 
 
12870 
  def read(self, iprot):
12871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12873 
      return
12874 
    iprot.readStructBegin()
12875 
    while True:
12876 
      (fname, ftype, fid) = iprot.readFieldBegin()
12877 
      if ftype == TType.STOP:
12878 
        break
4581 phani.kuma 12879 
      if fid == 0:
12880 
        if ftype == TType.LIST:
12881 
          self.success = []
5031 varun.gupt 12882 
          (_etype270, _size267) = iprot.readListBegin()
12883 
          for _i271 in xrange(_size267):
12884 
            _elem272 = Order()
12885 
            _elem272.read(iprot)
12886 
            self.success.append(_elem272)
4581 phani.kuma 12887 
          iprot.readListEnd()
12888 
        else:
12889 
          iprot.skip(ftype)
4910 phani.kuma 12890 
      else:
12891 
        iprot.skip(ftype)
12892 
      iprot.readFieldEnd()
12893 
    iprot.readStructEnd()
12894 
 
12895 
  def write(self, oprot):
12896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12898 
      return
12899 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
12900 
    if self.success is not None:
12901 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12902 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12903 
      for iter273 in self.success:
12904 
        iter273.write(oprot)
4910 phani.kuma 12905 
      oprot.writeListEnd()
12906 
      oprot.writeFieldEnd()
12907 
    oprot.writeFieldStop()
12908 
    oprot.writeStructEnd()
12909 
 
12910 
  def validate(self):
12911 
    return
12912 
 
12913 
 
12914 
  def __repr__(self):
12915 
    L = ['%s=%r' % (key, value)
12916 
      for key, value in self.__dict__.iteritems()]
12917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12918 
 
12919 
  def __eq__(self, other):
12920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12921 
 
12922 
  def __ne__(self, other):
12923 
    return not (self == other)
12924 
 
12925 
class markOrdersAsLocalConnected_args:
12926 
  """
12927 
  Attributes:
12928 
   - providerId
12929 
   - local_connected_orders
12930 
  """
12931 
 
12932 
  thrift_spec = (
12933 
    None, # 0
12934 
    (1, TType.I64, 'providerId', None, None, ), # 1
12935 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
12936 
  )
12937 
 
12938 
  def __init__(self, providerId=None, local_connected_orders=None,):
12939 
    self.providerId = providerId
12940 
    self.local_connected_orders = local_connected_orders
12941 
 
12942 
  def read(self, iprot):
12943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12945 
      return
12946 
    iprot.readStructBegin()
12947 
    while True:
12948 
      (fname, ftype, fid) = iprot.readFieldBegin()
12949 
      if ftype == TType.STOP:
12950 
        break
12951 
      if fid == 1:
12952 
        if ftype == TType.I64:
12953 
          self.providerId = iprot.readI64();
12954 
        else:
12955 
          iprot.skip(ftype)
12956 
      elif fid == 2:
12957 
        if ftype == TType.MAP:
12958 
          self.local_connected_orders = {}
5031 varun.gupt 12959 
          (_ktype275, _vtype276, _size274 ) = iprot.readMapBegin()
12960 
          for _i278 in xrange(_size274):
12961 
            _key279 = iprot.readString();
12962 
            _val280 = iprot.readString();
12963 
            self.local_connected_orders[_key279] = _val280
4910 phani.kuma 12964 
          iprot.readMapEnd()
12965 
        else:
12966 
          iprot.skip(ftype)
12967 
      else:
12968 
        iprot.skip(ftype)
12969 
      iprot.readFieldEnd()
12970 
    iprot.readStructEnd()
12971 
 
12972 
  def write(self, oprot):
12973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12975 
      return
12976 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
12977 
    if self.providerId is not None:
12978 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12979 
      oprot.writeI64(self.providerId)
12980 
      oprot.writeFieldEnd()
12981 
    if self.local_connected_orders is not None:
12982 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
12983 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
5031 varun.gupt 12984 
      for kiter281,viter282 in self.local_connected_orders.items():
12985 
        oprot.writeString(kiter281)
12986 
        oprot.writeString(viter282)
4910 phani.kuma 12987 
      oprot.writeMapEnd()
12988 
      oprot.writeFieldEnd()
12989 
    oprot.writeFieldStop()
12990 
    oprot.writeStructEnd()
12991 
 
12992 
  def validate(self):
12993 
    return
12994 
 
12995 
 
12996 
  def __repr__(self):
12997 
    L = ['%s=%r' % (key, value)
12998 
      for key, value in self.__dict__.iteritems()]
12999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13000 
 
13001 
  def __eq__(self, other):
13002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13003 
 
13004 
  def __ne__(self, other):
13005 
    return not (self == other)
13006 
 
13007 
class markOrdersAsLocalConnected_result:
13008 
  """
13009 
  Attributes:
13010 
   - ex
13011 
  """
13012 
 
13013 
  thrift_spec = (
13014 
    None, # 0
13015 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13016 
  )
13017 
 
13018 
  def __init__(self, ex=None,):
13019 
    self.ex = ex
13020 
 
13021 
  def read(self, iprot):
13022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13024 
      return
13025 
    iprot.readStructBegin()
13026 
    while True:
13027 
      (fname, ftype, fid) = iprot.readFieldBegin()
13028 
      if ftype == TType.STOP:
13029 
        break
13030 
      if fid == 1:
3064 chandransh 13031 
        if ftype == TType.STRUCT:
13032 
          self.ex = TransactionServiceException()
13033 
          self.ex.read(iprot)
1627 ankur.sing 13034 
        else:
13035 
          iprot.skip(ftype)
13036 
      else:
13037 
        iprot.skip(ftype)
13038 
      iprot.readFieldEnd()
13039 
    iprot.readStructEnd()
13040 
 
13041 
  def write(self, oprot):
13042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13044 
      return
4910 phani.kuma 13045 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
13046 
    if self.ex is not None:
13047 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13048 
      self.ex.write(oprot)
13049 
      oprot.writeFieldEnd()
13050 
    oprot.writeFieldStop()
13051 
    oprot.writeStructEnd()
13052 
 
13053 
  def validate(self):
13054 
    return
13055 
 
13056 
 
13057 
  def __repr__(self):
13058 
    L = ['%s=%r' % (key, value)
13059 
      for key, value in self.__dict__.iteritems()]
13060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13061 
 
13062 
  def __eq__(self, other):
13063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13064 
 
13065 
  def __ne__(self, other):
13066 
    return not (self == other)
13067 
 
13068 
class getOrdersNotLocalConnected_args:
13069 
  """
13070 
  Attributes:
13071 
   - providerId
13072 
  """
13073 
 
13074 
  thrift_spec = (
13075 
    None, # 0
13076 
    (1, TType.I64, 'providerId', None, None, ), # 1
13077 
  )
13078 
 
13079 
  def __init__(self, providerId=None,):
13080 
    self.providerId = providerId
13081 
 
13082 
  def read(self, iprot):
13083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13085 
      return
13086 
    iprot.readStructBegin()
13087 
    while True:
13088 
      (fname, ftype, fid) = iprot.readFieldBegin()
13089 
      if ftype == TType.STOP:
13090 
        break
13091 
      if fid == 1:
13092 
        if ftype == TType.I64:
13093 
          self.providerId = iprot.readI64();
13094 
        else:
13095 
          iprot.skip(ftype)
13096 
      else:
13097 
        iprot.skip(ftype)
13098 
      iprot.readFieldEnd()
13099 
    iprot.readStructEnd()
13100 
 
13101 
  def write(self, oprot):
13102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13104 
      return
13105 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
13106 
    if self.providerId is not None:
13107 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13108 
      oprot.writeI64(self.providerId)
13109 
      oprot.writeFieldEnd()
13110 
    oprot.writeFieldStop()
13111 
    oprot.writeStructEnd()
13112 
 
13113 
  def validate(self):
13114 
    return
13115 
 
13116 
 
13117 
  def __repr__(self):
13118 
    L = ['%s=%r' % (key, value)
13119 
      for key, value in self.__dict__.iteritems()]
13120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13121 
 
13122 
  def __eq__(self, other):
13123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13124 
 
13125 
  def __ne__(self, other):
13126 
    return not (self == other)
13127 
 
13128 
class getOrdersNotLocalConnected_result:
13129 
  """
13130 
  Attributes:
13131 
   - success
13132 
  """
13133 
 
13134 
  thrift_spec = (
13135 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13136 
  )
13137 
 
13138 
  def __init__(self, success=None,):
13139 
    self.success = success
13140 
 
13141 
  def read(self, iprot):
13142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13144 
      return
13145 
    iprot.readStructBegin()
13146 
    while True:
13147 
      (fname, ftype, fid) = iprot.readFieldBegin()
13148 
      if ftype == TType.STOP:
13149 
        break
13150 
      if fid == 0:
13151 
        if ftype == TType.LIST:
13152 
          self.success = []
5031 varun.gupt 13153 
          (_etype286, _size283) = iprot.readListBegin()
13154 
          for _i287 in xrange(_size283):
13155 
            _elem288 = Order()
13156 
            _elem288.read(iprot)
13157 
            self.success.append(_elem288)
4910 phani.kuma 13158 
          iprot.readListEnd()
13159 
        else:
13160 
          iprot.skip(ftype)
13161 
      else:
13162 
        iprot.skip(ftype)
13163 
      iprot.readFieldEnd()
13164 
    iprot.readStructEnd()
13165 
 
13166 
  def write(self, oprot):
13167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13169 
      return
13170 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 13171 
    if self.success is not None:
13172 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13173 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13174 
      for iter289 in self.success:
13175 
        iter289.write(oprot)
4581 phani.kuma 13176 
      oprot.writeListEnd()
13177 
      oprot.writeFieldEnd()
4910 phani.kuma 13178 
    oprot.writeFieldStop()
13179 
    oprot.writeStructEnd()
13180 
 
13181 
  def validate(self):
13182 
    return
13183 
 
13184 
 
13185 
  def __repr__(self):
13186 
    L = ['%s=%r' % (key, value)
13187 
      for key, value in self.__dict__.iteritems()]
13188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13189 
 
13190 
  def __eq__(self, other):
13191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13192 
 
13193 
  def __ne__(self, other):
13194 
    return not (self == other)
13195 
 
13196 
class markOrdersAsDestinationCityReached_args:
13197 
  """
13198 
  Attributes:
13199 
   - providerId
13200 
   - destination_city_reached_orders
13201 
  """
13202 
 
13203 
  thrift_spec = (
13204 
    None, # 0
13205 
    (1, TType.I64, 'providerId', None, None, ), # 1
13206 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13207 
  )
13208 
 
13209 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
13210 
    self.providerId = providerId
13211 
    self.destination_city_reached_orders = destination_city_reached_orders
13212 
 
13213 
  def read(self, iprot):
13214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13216 
      return
13217 
    iprot.readStructBegin()
13218 
    while True:
13219 
      (fname, ftype, fid) = iprot.readFieldBegin()
13220 
      if ftype == TType.STOP:
13221 
        break
13222 
      if fid == 1:
13223 
        if ftype == TType.I64:
13224 
          self.providerId = iprot.readI64();
13225 
        else:
13226 
          iprot.skip(ftype)
13227 
      elif fid == 2:
13228 
        if ftype == TType.MAP:
13229 
          self.destination_city_reached_orders = {}
5031 varun.gupt 13230 
          (_ktype291, _vtype292, _size290 ) = iprot.readMapBegin()
13231 
          for _i294 in xrange(_size290):
13232 
            _key295 = iprot.readString();
13233 
            _val296 = iprot.readString();
13234 
            self.destination_city_reached_orders[_key295] = _val296
4910 phani.kuma 13235 
          iprot.readMapEnd()
13236 
        else:
13237 
          iprot.skip(ftype)
13238 
      else:
13239 
        iprot.skip(ftype)
13240 
      iprot.readFieldEnd()
13241 
    iprot.readStructEnd()
13242 
 
13243 
  def write(self, oprot):
13244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13246 
      return
13247 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
13248 
    if self.providerId is not None:
13249 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13250 
      oprot.writeI64(self.providerId)
13251 
      oprot.writeFieldEnd()
13252 
    if self.destination_city_reached_orders is not None:
13253 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
13254 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
5031 varun.gupt 13255 
      for kiter297,viter298 in self.destination_city_reached_orders.items():
13256 
        oprot.writeString(kiter297)
13257 
        oprot.writeString(viter298)
4910 phani.kuma 13258 
      oprot.writeMapEnd()
13259 
      oprot.writeFieldEnd()
13260 
    oprot.writeFieldStop()
13261 
    oprot.writeStructEnd()
13262 
 
13263 
  def validate(self):
13264 
    return
13265 
 
13266 
 
13267 
  def __repr__(self):
13268 
    L = ['%s=%r' % (key, value)
13269 
      for key, value in self.__dict__.iteritems()]
13270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13271 
 
13272 
  def __eq__(self, other):
13273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13274 
 
13275 
  def __ne__(self, other):
13276 
    return not (self == other)
13277 
 
13278 
class markOrdersAsDestinationCityReached_result:
13279 
  """
13280 
  Attributes:
13281 
   - ex
13282 
  """
13283 
 
13284 
  thrift_spec = (
13285 
    None, # 0
13286 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13287 
  )
13288 
 
13289 
  def __init__(self, ex=None,):
13290 
    self.ex = ex
13291 
 
13292 
  def read(self, iprot):
13293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13295 
      return
13296 
    iprot.readStructBegin()
13297 
    while True:
13298 
      (fname, ftype, fid) = iprot.readFieldBegin()
13299 
      if ftype == TType.STOP:
13300 
        break
13301 
      if fid == 1:
13302 
        if ftype == TType.STRUCT:
13303 
          self.ex = TransactionServiceException()
13304 
          self.ex.read(iprot)
13305 
        else:
13306 
          iprot.skip(ftype)
13307 
      else:
13308 
        iprot.skip(ftype)
13309 
      iprot.readFieldEnd()
13310 
    iprot.readStructEnd()
13311 
 
13312 
  def write(self, oprot):
13313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13315 
      return
13316 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 13317 
    if self.ex is not None:
3064 chandransh 13318 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13319 
      self.ex.write(oprot)
1627 ankur.sing 13320 
      oprot.writeFieldEnd()
13321 
    oprot.writeFieldStop()
13322 
    oprot.writeStructEnd()
13323 
 
3431 rajveer 13324 
  def validate(self):
13325 
    return
13326 
 
13327 
 
1627 ankur.sing 13328 
  def __repr__(self):
13329 
    L = ['%s=%r' % (key, value)
13330 
      for key, value in self.__dict__.iteritems()]
13331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13332 
 
13333 
  def __eq__(self, other):
13334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13335 
 
13336 
  def __ne__(self, other):
13337 
    return not (self == other)
13338 
 
4910 phani.kuma 13339 
class markOrdersAsFirstDeliveryAttempted_args:
13340 
  """
13341 
  Attributes:
13342 
   - providerId
13343 
   - first_atdl_orders
13344 
  """
13345 
 
13346 
  thrift_spec = (
13347 
    None, # 0
13348 
    (1, TType.I64, 'providerId', None, None, ), # 1
13349 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13350 
  )
13351 
 
13352 
  def __init__(self, providerId=None, first_atdl_orders=None,):
13353 
    self.providerId = providerId
13354 
    self.first_atdl_orders = first_atdl_orders
13355 
 
13356 
  def read(self, iprot):
13357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13359 
      return
13360 
    iprot.readStructBegin()
13361 
    while True:
13362 
      (fname, ftype, fid) = iprot.readFieldBegin()
13363 
      if ftype == TType.STOP:
13364 
        break
13365 
      if fid == 1:
13366 
        if ftype == TType.I64:
13367 
          self.providerId = iprot.readI64();
13368 
        else:
13369 
          iprot.skip(ftype)
13370 
      elif fid == 2:
13371 
        if ftype == TType.MAP:
13372 
          self.first_atdl_orders = {}
5031 varun.gupt 13373 
          (_ktype300, _vtype301, _size299 ) = iprot.readMapBegin()
13374 
          for _i303 in xrange(_size299):
13375 
            _key304 = iprot.readString();
13376 
            _val305 = iprot.readString();
13377 
            self.first_atdl_orders[_key304] = _val305
4910 phani.kuma 13378 
          iprot.readMapEnd()
13379 
        else:
13380 
          iprot.skip(ftype)
13381 
      else:
13382 
        iprot.skip(ftype)
13383 
      iprot.readFieldEnd()
13384 
    iprot.readStructEnd()
13385 
 
13386 
  def write(self, oprot):
13387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13389 
      return
13390 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
13391 
    if self.providerId is not None:
13392 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13393 
      oprot.writeI64(self.providerId)
13394 
      oprot.writeFieldEnd()
13395 
    if self.first_atdl_orders is not None:
13396 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
13397 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
5031 varun.gupt 13398 
      for kiter306,viter307 in self.first_atdl_orders.items():
13399 
        oprot.writeString(kiter306)
13400 
        oprot.writeString(viter307)
4910 phani.kuma 13401 
      oprot.writeMapEnd()
13402 
      oprot.writeFieldEnd()
13403 
    oprot.writeFieldStop()
13404 
    oprot.writeStructEnd()
13405 
 
13406 
  def validate(self):
13407 
    return
13408 
 
13409 
 
13410 
  def __repr__(self):
13411 
    L = ['%s=%r' % (key, value)
13412 
      for key, value in self.__dict__.iteritems()]
13413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13414 
 
13415 
  def __eq__(self, other):
13416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13417 
 
13418 
  def __ne__(self, other):
13419 
    return not (self == other)
13420 
 
13421 
class markOrdersAsFirstDeliveryAttempted_result:
13422 
  """
13423 
  Attributes:
13424 
   - ex
13425 
  """
13426 
 
13427 
  thrift_spec = (
13428 
    None, # 0
13429 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13430 
  )
13431 
 
13432 
  def __init__(self, ex=None,):
13433 
    self.ex = ex
13434 
 
13435 
  def read(self, iprot):
13436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13438 
      return
13439 
    iprot.readStructBegin()
13440 
    while True:
13441 
      (fname, ftype, fid) = iprot.readFieldBegin()
13442 
      if ftype == TType.STOP:
13443 
        break
13444 
      if fid == 1:
13445 
        if ftype == TType.STRUCT:
13446 
          self.ex = TransactionServiceException()
13447 
          self.ex.read(iprot)
13448 
        else:
13449 
          iprot.skip(ftype)
13450 
      else:
13451 
        iprot.skip(ftype)
13452 
      iprot.readFieldEnd()
13453 
    iprot.readStructEnd()
13454 
 
13455 
  def write(self, oprot):
13456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13458 
      return
13459 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
13460 
    if self.ex is not None:
13461 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13462 
      self.ex.write(oprot)
13463 
      oprot.writeFieldEnd()
13464 
    oprot.writeFieldStop()
13465 
    oprot.writeStructEnd()
13466 
 
13467 
  def validate(self):
13468 
    return
13469 
 
13470 
 
13471 
  def __repr__(self):
13472 
    L = ['%s=%r' % (key, value)
13473 
      for key, value in self.__dict__.iteritems()]
13474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13475 
 
13476 
  def __eq__(self, other):
13477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13478 
 
13479 
  def __ne__(self, other):
13480 
    return not (self == other)
13481 
 
3064 chandransh 13482 
class getUndeliveredOrders_args:
1886 ankur.sing 13483 
  """
13484 
  Attributes:
3064 chandransh 13485 
   - providerId
13486 
   - warehouseId
1886 ankur.sing 13487 
  """
1627 ankur.sing 13488 
 
1886 ankur.sing 13489 
  thrift_spec = (
13490 
    None, # 0
3064 chandransh 13491 
    (1, TType.I64, 'providerId', None, None, ), # 1
13492 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 13493 
  )
13494 
 
3064 chandransh 13495 
  def __init__(self, providerId=None, warehouseId=None,):
13496 
    self.providerId = providerId
13497 
    self.warehouseId = warehouseId
1886 ankur.sing 13498 
 
13499 
  def read(self, iprot):
13500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13502 
      return
13503 
    iprot.readStructBegin()
13504 
    while True:
13505 
      (fname, ftype, fid) = iprot.readFieldBegin()
13506 
      if ftype == TType.STOP:
13507 
        break
13508 
      if fid == 1:
13509 
        if ftype == TType.I64:
3064 chandransh 13510 
          self.providerId = iprot.readI64();
1886 ankur.sing 13511 
        else:
13512 
          iprot.skip(ftype)
3064 chandransh 13513 
      elif fid == 2:
13514 
        if ftype == TType.I64:
13515 
          self.warehouseId = iprot.readI64();
13516 
        else:
13517 
          iprot.skip(ftype)
1886 ankur.sing 13518 
      else:
13519 
        iprot.skip(ftype)
13520 
      iprot.readFieldEnd()
13521 
    iprot.readStructEnd()
13522 
 
13523 
  def write(self, oprot):
13524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13526 
      return
3064 chandransh 13527 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 13528 
    if self.providerId is not None:
3064 chandransh 13529 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13530 
      oprot.writeI64(self.providerId)
1886 ankur.sing 13531 
      oprot.writeFieldEnd()
3431 rajveer 13532 
    if self.warehouseId is not None:
3064 chandransh 13533 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13534 
      oprot.writeI64(self.warehouseId)
13535 
      oprot.writeFieldEnd()
1886 ankur.sing 13536 
    oprot.writeFieldStop()
13537 
    oprot.writeStructEnd()
13538 
 
3431 rajveer 13539 
  def validate(self):
13540 
    return
13541 
 
13542 
 
1886 ankur.sing 13543 
  def __repr__(self):
13544 
    L = ['%s=%r' % (key, value)
13545 
      for key, value in self.__dict__.iteritems()]
13546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13547 
 
13548 
  def __eq__(self, other):
13549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13550 
 
13551 
  def __ne__(self, other):
13552 
    return not (self == other)
13553 
 
3064 chandransh 13554 
class getUndeliveredOrders_result:
1886 ankur.sing 13555 
  """
13556 
  Attributes:
13557 
   - success
13558 
  """
13559 
 
13560 
  thrift_spec = (
13561 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13562 
  )
13563 
 
13564 
  def __init__(self, success=None,):
13565 
    self.success = success
13566 
 
13567 
  def read(self, iprot):
13568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13570 
      return
13571 
    iprot.readStructBegin()
13572 
    while True:
13573 
      (fname, ftype, fid) = iprot.readFieldBegin()
13574 
      if ftype == TType.STOP:
13575 
        break
13576 
      if fid == 0:
13577 
        if ftype == TType.LIST:
13578 
          self.success = []
5031 varun.gupt 13579 
          (_etype311, _size308) = iprot.readListBegin()
13580 
          for _i312 in xrange(_size308):
13581 
            _elem313 = Order()
13582 
            _elem313.read(iprot)
13583 
            self.success.append(_elem313)
1886 ankur.sing 13584 
          iprot.readListEnd()
13585 
        else:
13586 
          iprot.skip(ftype)
13587 
      else:
13588 
        iprot.skip(ftype)
13589 
      iprot.readFieldEnd()
13590 
    iprot.readStructEnd()
13591 
 
13592 
  def write(self, oprot):
13593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13595 
      return
3064 chandransh 13596 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 13597 
    if self.success is not None:
1886 ankur.sing 13598 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13599 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13600 
      for iter314 in self.success:
13601 
        iter314.write(oprot)
1886 ankur.sing 13602 
      oprot.writeListEnd()
13603 
      oprot.writeFieldEnd()
13604 
    oprot.writeFieldStop()
13605 
    oprot.writeStructEnd()
13606 
 
3431 rajveer 13607 
  def validate(self):
13608 
    return
13609 
 
13610 
 
1886 ankur.sing 13611 
  def __repr__(self):
13612 
    L = ['%s=%r' % (key, value)
13613 
      for key, value in self.__dict__.iteritems()]
13614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13615 
 
13616 
  def __eq__(self, other):
13617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13618 
 
13619 
  def __ne__(self, other):
13620 
    return not (self == other)
13621 
 
4783 phani.kuma 13622 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
13623 
 
13624 
  thrift_spec = (
13625 
  )
13626 
 
13627 
  def read(self, iprot):
13628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13630 
      return
13631 
    iprot.readStructBegin()
13632 
    while True:
13633 
      (fname, ftype, fid) = iprot.readFieldBegin()
13634 
      if ftype == TType.STOP:
13635 
        break
13636 
      else:
13637 
        iprot.skip(ftype)
13638 
      iprot.readFieldEnd()
13639 
    iprot.readStructEnd()
13640 
 
13641 
  def write(self, oprot):
13642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13644 
      return
13645 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
13646 
    oprot.writeFieldStop()
13647 
    oprot.writeStructEnd()
13648 
 
13649 
  def validate(self):
13650 
    return
13651 
 
13652 
 
13653 
  def __repr__(self):
13654 
    L = ['%s=%r' % (key, value)
13655 
      for key, value in self.__dict__.iteritems()]
13656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13657 
 
13658 
  def __eq__(self, other):
13659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13660 
 
13661 
  def __ne__(self, other):
13662 
    return not (self == other)
13663 
 
13664 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
13665 
  """
13666 
  Attributes:
13667 
   - success
13668 
  """
13669 
 
13670 
  thrift_spec = (
13671 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13672 
  )
13673 
 
13674 
  def __init__(self, success=None,):
13675 
    self.success = success
13676 
 
13677 
  def read(self, iprot):
13678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13680 
      return
13681 
    iprot.readStructBegin()
13682 
    while True:
13683 
      (fname, ftype, fid) = iprot.readFieldBegin()
13684 
      if ftype == TType.STOP:
13685 
        break
13686 
      if fid == 0:
13687 
        if ftype == TType.LIST:
13688 
          self.success = []
5031 varun.gupt 13689 
          (_etype318, _size315) = iprot.readListBegin()
13690 
          for _i319 in xrange(_size315):
13691 
            _elem320 = Order()
13692 
            _elem320.read(iprot)
13693 
            self.success.append(_elem320)
4783 phani.kuma 13694 
          iprot.readListEnd()
13695 
        else:
13696 
          iprot.skip(ftype)
13697 
      else:
13698 
        iprot.skip(ftype)
13699 
      iprot.readFieldEnd()
13700 
    iprot.readStructEnd()
13701 
 
13702 
  def write(self, oprot):
13703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13705 
      return
13706 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
13707 
    if self.success is not None:
13708 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13709 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13710 
      for iter321 in self.success:
13711 
        iter321.write(oprot)
4783 phani.kuma 13712 
      oprot.writeListEnd()
13713 
      oprot.writeFieldEnd()
13714 
    oprot.writeFieldStop()
13715 
    oprot.writeStructEnd()
13716 
 
13717 
  def validate(self):
13718 
    return
13719 
 
13720 
 
13721 
  def __repr__(self):
13722 
    L = ['%s=%r' % (key, value)
13723 
      for key, value in self.__dict__.iteritems()]
13724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13725 
 
13726 
  def __eq__(self, other):
13727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13728 
 
13729 
  def __ne__(self, other):
13730 
    return not (self == other)
13731 
 
2536 chandransh 13732 
class toggleDOAFlag_args:
13733 
  """
13734 
  Attributes:
13735 
   - orderId
13736 
  """
1886 ankur.sing 13737 
 
2536 chandransh 13738 
  thrift_spec = (
13739 
    None, # 0
13740 
    (1, TType.I64, 'orderId', None, None, ), # 1
13741 
  )
13742 
 
13743 
  def __init__(self, orderId=None,):
13744 
    self.orderId = orderId
13745 
 
13746 
  def read(self, iprot):
13747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13749 
      return
13750 
    iprot.readStructBegin()
13751 
    while True:
13752 
      (fname, ftype, fid) = iprot.readFieldBegin()
13753 
      if ftype == TType.STOP:
13754 
        break
13755 
      if fid == 1:
13756 
        if ftype == TType.I64:
13757 
          self.orderId = iprot.readI64();
13758 
        else:
13759 
          iprot.skip(ftype)
13760 
      else:
13761 
        iprot.skip(ftype)
13762 
      iprot.readFieldEnd()
13763 
    iprot.readStructEnd()
13764 
 
13765 
  def write(self, oprot):
13766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13768 
      return
13769 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 13770 
    if self.orderId is not None:
2536 chandransh 13771 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13772 
      oprot.writeI64(self.orderId)
13773 
      oprot.writeFieldEnd()
13774 
    oprot.writeFieldStop()
13775 
    oprot.writeStructEnd()
13776 
 
3431 rajveer 13777 
  def validate(self):
13778 
    return
13779 
 
13780 
 
2536 chandransh 13781 
  def __repr__(self):
13782 
    L = ['%s=%r' % (key, value)
13783 
      for key, value in self.__dict__.iteritems()]
13784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13785 
 
13786 
  def __eq__(self, other):
13787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13788 
 
13789 
  def __ne__(self, other):
13790 
    return not (self == other)
13791 
 
13792 
class toggleDOAFlag_result:
13793 
  """
13794 
  Attributes:
13795 
   - success
13796 
   - ex
13797 
  """
13798 
 
13799 
  thrift_spec = (
13800 
    (0, TType.BOOL, 'success', None, None, ), # 0
13801 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13802 
  )
13803 
 
13804 
  def __init__(self, success=None, ex=None,):
13805 
    self.success = success
13806 
    self.ex = ex
13807 
 
13808 
  def read(self, iprot):
13809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13811 
      return
13812 
    iprot.readStructBegin()
13813 
    while True:
13814 
      (fname, ftype, fid) = iprot.readFieldBegin()
13815 
      if ftype == TType.STOP:
13816 
        break
13817 
      if fid == 0:
13818 
        if ftype == TType.BOOL:
13819 
          self.success = iprot.readBool();
13820 
        else:
13821 
          iprot.skip(ftype)
13822 
      elif fid == 1:
13823 
        if ftype == TType.STRUCT:
13824 
          self.ex = TransactionServiceException()
13825 
          self.ex.read(iprot)
13826 
        else:
13827 
          iprot.skip(ftype)
13828 
      else:
13829 
        iprot.skip(ftype)
13830 
      iprot.readFieldEnd()
13831 
    iprot.readStructEnd()
13832 
 
13833 
  def write(self, oprot):
13834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13836 
      return
13837 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 13838 
    if self.success is not None:
2536 chandransh 13839 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13840 
      oprot.writeBool(self.success)
13841 
      oprot.writeFieldEnd()
3431 rajveer 13842 
    if self.ex is not None:
2536 chandransh 13843 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13844 
      self.ex.write(oprot)
13845 
      oprot.writeFieldEnd()
13846 
    oprot.writeFieldStop()
13847 
    oprot.writeStructEnd()
13848 
 
3431 rajveer 13849 
  def validate(self):
13850 
    return
13851 
 
13852 
 
2536 chandransh 13853 
  def __repr__(self):
13854 
    L = ['%s=%r' % (key, value)
13855 
      for key, value in self.__dict__.iteritems()]
13856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13857 
 
13858 
  def __eq__(self, other):
13859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13860 
 
13861 
  def __ne__(self, other):
13862 
    return not (self == other)
13863 
 
4712 rajveer 13864 
class markOrderAsDelivered_args:
13865 
  """
13866 
  Attributes:
13867 
   - orderId
13868 
   - deliveryTimestamp
13869 
   - receiver
13870 
  """
13871 
 
13872 
  thrift_spec = None
13873 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
13874 
    self.orderId = orderId
13875 
    self.deliveryTimestamp = deliveryTimestamp
13876 
    self.receiver = receiver
13877 
 
13878 
  def read(self, iprot):
13879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13881 
      return
13882 
    iprot.readStructBegin()
13883 
    while True:
13884 
      (fname, ftype, fid) = iprot.readFieldBegin()
13885 
      if ftype == TType.STOP:
13886 
        break
13887 
      if fid == 1:
13888 
        if ftype == TType.I64:
13889 
          self.orderId = iprot.readI64();
13890 
        else:
13891 
          iprot.skip(ftype)
13892 
      elif fid == 2:
13893 
        if ftype == TType.I64:
13894 
          self.deliveryTimestamp = iprot.readI64();
13895 
        else:
13896 
          iprot.skip(ftype)
13897 
      elif fid == -1:
13898 
        if ftype == TType.STRING:
13899 
          self.receiver = iprot.readString();
13900 
        else:
13901 
          iprot.skip(ftype)
13902 
      else:
13903 
        iprot.skip(ftype)
13904 
      iprot.readFieldEnd()
13905 
    iprot.readStructEnd()
13906 
 
13907 
  def write(self, oprot):
13908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13910 
      return
13911 
    oprot.writeStructBegin('markOrderAsDelivered_args')
13912 
    if self.receiver is not None:
13913 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
13914 
      oprot.writeString(self.receiver)
13915 
      oprot.writeFieldEnd()
13916 
    if self.orderId is not None:
13917 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13918 
      oprot.writeI64(self.orderId)
13919 
      oprot.writeFieldEnd()
13920 
    if self.deliveryTimestamp is not None:
13921 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
13922 
      oprot.writeI64(self.deliveryTimestamp)
13923 
      oprot.writeFieldEnd()
13924 
    oprot.writeFieldStop()
13925 
    oprot.writeStructEnd()
13926 
 
13927 
  def validate(self):
13928 
    return
13929 
 
13930 
 
13931 
  def __repr__(self):
13932 
    L = ['%s=%r' % (key, value)
13933 
      for key, value in self.__dict__.iteritems()]
13934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13935 
 
13936 
  def __eq__(self, other):
13937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13938 
 
13939 
  def __ne__(self, other):
13940 
    return not (self == other)
13941 
 
13942 
class markOrderAsDelivered_result:
13943 
  """
13944 
  Attributes:
13945 
   - ex
13946 
  """
13947 
 
13948 
  thrift_spec = (
13949 
    None, # 0
13950 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13951 
  )
13952 
 
13953 
  def __init__(self, ex=None,):
13954 
    self.ex = ex
13955 
 
13956 
  def read(self, iprot):
13957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13959 
      return
13960 
    iprot.readStructBegin()
13961 
    while True:
13962 
      (fname, ftype, fid) = iprot.readFieldBegin()
13963 
      if ftype == TType.STOP:
13964 
        break
13965 
      if fid == 1:
13966 
        if ftype == TType.STRUCT:
13967 
          self.ex = TransactionServiceException()
13968 
          self.ex.read(iprot)
13969 
        else:
13970 
          iprot.skip(ftype)
13971 
      else:
13972 
        iprot.skip(ftype)
13973 
      iprot.readFieldEnd()
13974 
    iprot.readStructEnd()
13975 
 
13976 
  def write(self, oprot):
13977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13979 
      return
13980 
    oprot.writeStructBegin('markOrderAsDelivered_result')
13981 
    if self.ex is not None:
13982 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13983 
      self.ex.write(oprot)
13984 
      oprot.writeFieldEnd()
13985 
    oprot.writeFieldStop()
13986 
    oprot.writeStructEnd()
13987 
 
13988 
  def validate(self):
13989 
    return
13990 
 
13991 
 
13992 
  def __repr__(self):
13993 
    L = ['%s=%r' % (key, value)
13994 
      for key, value in self.__dict__.iteritems()]
13995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13996 
 
13997 
  def __eq__(self, other):
13998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13999 
 
14000 
  def __ne__(self, other):
14001 
    return not (self == other)
14002 
 
4454 rajveer 14003 
class markOrderDoaRequestReceived_args:
14004 
  """
14005 
  Attributes:
14006 
   - orderId
14007 
  """
14008 
 
14009 
  thrift_spec = (
14010 
    None, # 0
14011 
    (1, TType.I64, 'orderId', None, None, ), # 1
14012 
  )
14013 
 
14014 
  def __init__(self, orderId=None,):
14015 
    self.orderId = orderId
14016 
 
14017 
  def read(self, iprot):
14018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14020 
      return
14021 
    iprot.readStructBegin()
14022 
    while True:
14023 
      (fname, ftype, fid) = iprot.readFieldBegin()
14024 
      if ftype == TType.STOP:
14025 
        break
14026 
      if fid == 1:
14027 
        if ftype == TType.I64:
14028 
          self.orderId = iprot.readI64();
14029 
        else:
14030 
          iprot.skip(ftype)
14031 
      else:
14032 
        iprot.skip(ftype)
14033 
      iprot.readFieldEnd()
14034 
    iprot.readStructEnd()
14035 
 
14036 
  def write(self, oprot):
14037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14039 
      return
14040 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
14041 
    if self.orderId is not None:
14042 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14043 
      oprot.writeI64(self.orderId)
14044 
      oprot.writeFieldEnd()
14045 
    oprot.writeFieldStop()
14046 
    oprot.writeStructEnd()
14047 
 
14048 
  def validate(self):
14049 
    return
14050 
 
14051 
 
14052 
  def __repr__(self):
14053 
    L = ['%s=%r' % (key, value)
14054 
      for key, value in self.__dict__.iteritems()]
14055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14056 
 
14057 
  def __eq__(self, other):
14058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14059 
 
14060 
  def __ne__(self, other):
14061 
    return not (self == other)
14062 
 
14063 
class markOrderDoaRequestReceived_result:
14064 
  """
14065 
  Attributes:
14066 
   - success
14067 
   - ex
14068 
  """
14069 
 
14070 
  thrift_spec = (
14071 
    (0, TType.BOOL, 'success', None, None, ), # 0
14072 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14073 
  )
14074 
 
14075 
  def __init__(self, success=None, ex=None,):
14076 
    self.success = success
14077 
    self.ex = ex
14078 
 
14079 
  def read(self, iprot):
14080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14082 
      return
14083 
    iprot.readStructBegin()
14084 
    while True:
14085 
      (fname, ftype, fid) = iprot.readFieldBegin()
14086 
      if ftype == TType.STOP:
14087 
        break
14088 
      if fid == 0:
14089 
        if ftype == TType.BOOL:
14090 
          self.success = iprot.readBool();
14091 
        else:
14092 
          iprot.skip(ftype)
14093 
      elif fid == 1:
14094 
        if ftype == TType.STRUCT:
14095 
          self.ex = TransactionServiceException()
14096 
          self.ex.read(iprot)
14097 
        else:
14098 
          iprot.skip(ftype)
14099 
      else:
14100 
        iprot.skip(ftype)
14101 
      iprot.readFieldEnd()
14102 
    iprot.readStructEnd()
14103 
 
14104 
  def write(self, oprot):
14105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14107 
      return
14108 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
14109 
    if self.success is not None:
14110 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14111 
      oprot.writeBool(self.success)
14112 
      oprot.writeFieldEnd()
14113 
    if self.ex is not None:
14114 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14115 
      self.ex.write(oprot)
14116 
      oprot.writeFieldEnd()
14117 
    oprot.writeFieldStop()
14118 
    oprot.writeStructEnd()
14119 
 
14120 
  def validate(self):
14121 
    return
14122 
 
14123 
 
14124 
  def __repr__(self):
14125 
    L = ['%s=%r' % (key, value)
14126 
      for key, value in self.__dict__.iteritems()]
14127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14128 
 
14129 
  def __eq__(self, other):
14130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14131 
 
14132 
  def __ne__(self, other):
14133 
    return not (self == other)
14134 
 
14135 
class markOrderDoaRequestAuthorized_args:
14136 
  """
14137 
  Attributes:
14138 
   - orderId
14139 
   - isAuthorized
14140 
  """
14141 
 
14142 
  thrift_spec = (
14143 
    None, # 0
14144 
    (1, TType.I64, 'orderId', None, None, ), # 1
14145 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14146 
  )
14147 
 
14148 
  def __init__(self, orderId=None, isAuthorized=None,):
14149 
    self.orderId = orderId
14150 
    self.isAuthorized = isAuthorized
14151 
 
14152 
  def read(self, iprot):
14153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14155 
      return
14156 
    iprot.readStructBegin()
14157 
    while True:
14158 
      (fname, ftype, fid) = iprot.readFieldBegin()
14159 
      if ftype == TType.STOP:
14160 
        break
14161 
      if fid == 1:
14162 
        if ftype == TType.I64:
14163 
          self.orderId = iprot.readI64();
14164 
        else:
14165 
          iprot.skip(ftype)
14166 
      elif fid == 2:
14167 
        if ftype == TType.BOOL:
14168 
          self.isAuthorized = iprot.readBool();
14169 
        else:
14170 
          iprot.skip(ftype)
14171 
      else:
14172 
        iprot.skip(ftype)
14173 
      iprot.readFieldEnd()
14174 
    iprot.readStructEnd()
14175 
 
14176 
  def write(self, oprot):
14177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14179 
      return
14180 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
14181 
    if self.orderId is not None:
14182 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14183 
      oprot.writeI64(self.orderId)
14184 
      oprot.writeFieldEnd()
14185 
    if self.isAuthorized is not None:
14186 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14187 
      oprot.writeBool(self.isAuthorized)
14188 
      oprot.writeFieldEnd()
14189 
    oprot.writeFieldStop()
14190 
    oprot.writeStructEnd()
14191 
 
14192 
  def validate(self):
14193 
    return
14194 
 
14195 
 
14196 
  def __repr__(self):
14197 
    L = ['%s=%r' % (key, value)
14198 
      for key, value in self.__dict__.iteritems()]
14199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14200 
 
14201 
  def __eq__(self, other):
14202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14203 
 
14204 
  def __ne__(self, other):
14205 
    return not (self == other)
14206 
 
14207 
class markOrderDoaRequestAuthorized_result:
14208 
  """
14209 
  Attributes:
14210 
   - success
14211 
   - ex
14212 
  """
14213 
 
14214 
  thrift_spec = (
14215 
    (0, TType.BOOL, 'success', None, None, ), # 0
14216 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14217 
  )
14218 
 
14219 
  def __init__(self, success=None, ex=None,):
14220 
    self.success = success
14221 
    self.ex = ex
14222 
 
14223 
  def read(self, iprot):
14224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14226 
      return
14227 
    iprot.readStructBegin()
14228 
    while True:
14229 
      (fname, ftype, fid) = iprot.readFieldBegin()
14230 
      if ftype == TType.STOP:
14231 
        break
14232 
      if fid == 0:
14233 
        if ftype == TType.BOOL:
14234 
          self.success = iprot.readBool();
14235 
        else:
14236 
          iprot.skip(ftype)
14237 
      elif fid == 1:
14238 
        if ftype == TType.STRUCT:
14239 
          self.ex = TransactionServiceException()
14240 
          self.ex.read(iprot)
14241 
        else:
14242 
          iprot.skip(ftype)
14243 
      else:
14244 
        iprot.skip(ftype)
14245 
      iprot.readFieldEnd()
14246 
    iprot.readStructEnd()
14247 
 
14248 
  def write(self, oprot):
14249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14251 
      return
14252 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
14253 
    if self.success is not None:
14254 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14255 
      oprot.writeBool(self.success)
14256 
      oprot.writeFieldEnd()
14257 
    if self.ex is not None:
14258 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14259 
      self.ex.write(oprot)
14260 
      oprot.writeFieldEnd()
14261 
    oprot.writeFieldStop()
14262 
    oprot.writeStructEnd()
14263 
 
14264 
  def validate(self):
14265 
    return
14266 
 
14267 
 
14268 
  def __repr__(self):
14269 
    L = ['%s=%r' % (key, value)
14270 
      for key, value in self.__dict__.iteritems()]
14271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14272 
 
14273 
  def __eq__(self, other):
14274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14275 
 
14276 
  def __ne__(self, other):
14277 
    return not (self == other)
14278 
 
4488 rajveer 14279 
class markOrderReturnRequestReceived_args:
14280 
  """
14281 
  Attributes:
14282 
   - orderId
14283 
  """
14284 
 
14285 
  thrift_spec = (
14286 
    None, # 0
14287 
    (1, TType.I64, 'orderId', None, None, ), # 1
14288 
  )
14289 
 
14290 
  def __init__(self, orderId=None,):
14291 
    self.orderId = orderId
14292 
 
14293 
  def read(self, iprot):
14294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14296 
      return
14297 
    iprot.readStructBegin()
14298 
    while True:
14299 
      (fname, ftype, fid) = iprot.readFieldBegin()
14300 
      if ftype == TType.STOP:
14301 
        break
14302 
      if fid == 1:
14303 
        if ftype == TType.I64:
14304 
          self.orderId = iprot.readI64();
14305 
        else:
14306 
          iprot.skip(ftype)
14307 
      else:
14308 
        iprot.skip(ftype)
14309 
      iprot.readFieldEnd()
14310 
    iprot.readStructEnd()
14311 
 
14312 
  def write(self, oprot):
14313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14315 
      return
14316 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
14317 
    if self.orderId is not None:
14318 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14319 
      oprot.writeI64(self.orderId)
14320 
      oprot.writeFieldEnd()
14321 
    oprot.writeFieldStop()
14322 
    oprot.writeStructEnd()
14323 
 
14324 
  def validate(self):
14325 
    return
14326 
 
14327 
 
14328 
  def __repr__(self):
14329 
    L = ['%s=%r' % (key, value)
14330 
      for key, value in self.__dict__.iteritems()]
14331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14332 
 
14333 
  def __eq__(self, other):
14334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14335 
 
14336 
  def __ne__(self, other):
14337 
    return not (self == other)
14338 
 
14339 
class markOrderReturnRequestReceived_result:
14340 
  """
14341 
  Attributes:
14342 
   - success
14343 
   - ex
14344 
  """
14345 
 
14346 
  thrift_spec = (
14347 
    (0, TType.BOOL, 'success', None, None, ), # 0
14348 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14349 
  )
14350 
 
14351 
  def __init__(self, success=None, ex=None,):
14352 
    self.success = success
14353 
    self.ex = ex
14354 
 
14355 
  def read(self, iprot):
14356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14358 
      return
14359 
    iprot.readStructBegin()
14360 
    while True:
14361 
      (fname, ftype, fid) = iprot.readFieldBegin()
14362 
      if ftype == TType.STOP:
14363 
        break
14364 
      if fid == 0:
14365 
        if ftype == TType.BOOL:
14366 
          self.success = iprot.readBool();
14367 
        else:
14368 
          iprot.skip(ftype)
14369 
      elif fid == 1:
14370 
        if ftype == TType.STRUCT:
14371 
          self.ex = TransactionServiceException()
14372 
          self.ex.read(iprot)
14373 
        else:
14374 
          iprot.skip(ftype)
14375 
      else:
14376 
        iprot.skip(ftype)
14377 
      iprot.readFieldEnd()
14378 
    iprot.readStructEnd()
14379 
 
14380 
  def write(self, oprot):
14381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14383 
      return
14384 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
14385 
    if self.success is not None:
14386 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14387 
      oprot.writeBool(self.success)
14388 
      oprot.writeFieldEnd()
14389 
    if self.ex is not None:
14390 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14391 
      self.ex.write(oprot)
14392 
      oprot.writeFieldEnd()
14393 
    oprot.writeFieldStop()
14394 
    oprot.writeStructEnd()
14395 
 
14396 
  def validate(self):
14397 
    return
14398 
 
14399 
 
14400 
  def __repr__(self):
14401 
    L = ['%s=%r' % (key, value)
14402 
      for key, value in self.__dict__.iteritems()]
14403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14404 
 
14405 
  def __eq__(self, other):
14406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14407 
 
14408 
  def __ne__(self, other):
14409 
    return not (self == other)
14410 
 
14411 
class markOrderReturnRequestAuthorized_args:
14412 
  """
14413 
  Attributes:
14414 
   - orderId
14415 
   - isAuthorized
14416 
  """
14417 
 
14418 
  thrift_spec = (
14419 
    None, # 0
14420 
    (1, TType.I64, 'orderId', None, None, ), # 1
14421 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14422 
  )
14423 
 
14424 
  def __init__(self, orderId=None, isAuthorized=None,):
14425 
    self.orderId = orderId
14426 
    self.isAuthorized = isAuthorized
14427 
 
14428 
  def read(self, iprot):
14429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14431 
      return
14432 
    iprot.readStructBegin()
14433 
    while True:
14434 
      (fname, ftype, fid) = iprot.readFieldBegin()
14435 
      if ftype == TType.STOP:
14436 
        break
14437 
      if fid == 1:
14438 
        if ftype == TType.I64:
14439 
          self.orderId = iprot.readI64();
14440 
        else:
14441 
          iprot.skip(ftype)
14442 
      elif fid == 2:
14443 
        if ftype == TType.BOOL:
14444 
          self.isAuthorized = iprot.readBool();
14445 
        else:
14446 
          iprot.skip(ftype)
14447 
      else:
14448 
        iprot.skip(ftype)
14449 
      iprot.readFieldEnd()
14450 
    iprot.readStructEnd()
14451 
 
14452 
  def write(self, oprot):
14453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14455 
      return
14456 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
14457 
    if self.orderId is not None:
14458 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14459 
      oprot.writeI64(self.orderId)
14460 
      oprot.writeFieldEnd()
14461 
    if self.isAuthorized is not None:
14462 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14463 
      oprot.writeBool(self.isAuthorized)
14464 
      oprot.writeFieldEnd()
14465 
    oprot.writeFieldStop()
14466 
    oprot.writeStructEnd()
14467 
 
14468 
  def validate(self):
14469 
    return
14470 
 
14471 
 
14472 
  def __repr__(self):
14473 
    L = ['%s=%r' % (key, value)
14474 
      for key, value in self.__dict__.iteritems()]
14475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14476 
 
14477 
  def __eq__(self, other):
14478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14479 
 
14480 
  def __ne__(self, other):
14481 
    return not (self == other)
14482 
 
14483 
class markOrderReturnRequestAuthorized_result:
14484 
  """
14485 
  Attributes:
14486 
   - success
14487 
   - ex
14488 
  """
14489 
 
14490 
  thrift_spec = (
14491 
    (0, TType.BOOL, 'success', None, None, ), # 0
14492 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14493 
  )
14494 
 
14495 
  def __init__(self, success=None, ex=None,):
14496 
    self.success = success
14497 
    self.ex = ex
14498 
 
14499 
  def read(self, iprot):
14500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14502 
      return
14503 
    iprot.readStructBegin()
14504 
    while True:
14505 
      (fname, ftype, fid) = iprot.readFieldBegin()
14506 
      if ftype == TType.STOP:
14507 
        break
14508 
      if fid == 0:
14509 
        if ftype == TType.BOOL:
14510 
          self.success = iprot.readBool();
14511 
        else:
14512 
          iprot.skip(ftype)
14513 
      elif fid == 1:
14514 
        if ftype == TType.STRUCT:
14515 
          self.ex = TransactionServiceException()
14516 
          self.ex.read(iprot)
14517 
        else:
14518 
          iprot.skip(ftype)
14519 
      else:
14520 
        iprot.skip(ftype)
14521 
      iprot.readFieldEnd()
14522 
    iprot.readStructEnd()
14523 
 
14524 
  def write(self, oprot):
14525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14527 
      return
14528 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
14529 
    if self.success is not None:
14530 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14531 
      oprot.writeBool(self.success)
14532 
      oprot.writeFieldEnd()
14533 
    if self.ex is not None:
14534 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14535 
      self.ex.write(oprot)
14536 
      oprot.writeFieldEnd()
14537 
    oprot.writeFieldStop()
14538 
    oprot.writeStructEnd()
14539 
 
14540 
  def validate(self):
14541 
    return
14542 
 
14543 
 
14544 
  def __repr__(self):
14545 
    L = ['%s=%r' % (key, value)
14546 
      for key, value in self.__dict__.iteritems()]
14547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14548 
 
14549 
  def __eq__(self, other):
14550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14551 
 
14552 
  def __ne__(self, other):
14553 
    return not (self == other)
14554 
 
2536 chandransh 14555 
class requestPickupNumber_args:
14556 
  """
14557 
  Attributes:
14558 
   - orderId
4579 rajveer 14559 
   - providerId
2536 chandransh 14560 
  """
14561 
 
14562 
  thrift_spec = (
14563 
    None, # 0
14564 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 14565 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 14566 
  )
14567 
 
4579 rajveer 14568 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 14569 
    self.orderId = orderId
4579 rajveer 14570 
    self.providerId = providerId
2536 chandransh 14571 
 
14572 
  def read(self, iprot):
14573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14575 
      return
14576 
    iprot.readStructBegin()
14577 
    while True:
14578 
      (fname, ftype, fid) = iprot.readFieldBegin()
14579 
      if ftype == TType.STOP:
14580 
        break
14581 
      if fid == 1:
14582 
        if ftype == TType.I64:
14583 
          self.orderId = iprot.readI64();
14584 
        else:
14585 
          iprot.skip(ftype)
4579 rajveer 14586 
      elif fid == 2:
14587 
        if ftype == TType.I64:
14588 
          self.providerId = iprot.readI64();
14589 
        else:
14590 
          iprot.skip(ftype)
2536 chandransh 14591 
      else:
14592 
        iprot.skip(ftype)
14593 
      iprot.readFieldEnd()
14594 
    iprot.readStructEnd()
14595 
 
14596 
  def write(self, oprot):
14597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14599 
      return
14600 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 14601 
    if self.orderId is not None:
2536 chandransh 14602 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14603 
      oprot.writeI64(self.orderId)
14604 
      oprot.writeFieldEnd()
4579 rajveer 14605 
    if self.providerId is not None:
14606 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
14607 
      oprot.writeI64(self.providerId)
14608 
      oprot.writeFieldEnd()
2536 chandransh 14609 
    oprot.writeFieldStop()
14610 
    oprot.writeStructEnd()
14611 
 
3431 rajveer 14612 
  def validate(self):
14613 
    return
14614 
 
14615 
 
2536 chandransh 14616 
  def __repr__(self):
14617 
    L = ['%s=%r' % (key, value)
14618 
      for key, value in self.__dict__.iteritems()]
14619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14620 
 
14621 
  def __eq__(self, other):
14622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14623 
 
14624 
  def __ne__(self, other):
14625 
    return not (self == other)
14626 
 
14627 
class requestPickupNumber_result:
14628 
  """
14629 
  Attributes:
14630 
   - success
14631 
   - ex
14632 
  """
14633 
 
14634 
  thrift_spec = (
14635 
    (0, TType.BOOL, 'success', None, None, ), # 0
14636 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14637 
  )
14638 
 
14639 
  def __init__(self, success=None, ex=None,):
14640 
    self.success = success
14641 
    self.ex = ex
14642 
 
14643 
  def read(self, iprot):
14644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14646 
      return
14647 
    iprot.readStructBegin()
14648 
    while True:
14649 
      (fname, ftype, fid) = iprot.readFieldBegin()
14650 
      if ftype == TType.STOP:
14651 
        break
14652 
      if fid == 0:
14653 
        if ftype == TType.BOOL:
14654 
          self.success = iprot.readBool();
14655 
        else:
14656 
          iprot.skip(ftype)
14657 
      elif fid == 1:
14658 
        if ftype == TType.STRUCT:
14659 
          self.ex = TransactionServiceException()
14660 
          self.ex.read(iprot)
14661 
        else:
14662 
          iprot.skip(ftype)
14663 
      else:
14664 
        iprot.skip(ftype)
14665 
      iprot.readFieldEnd()
14666 
    iprot.readStructEnd()
14667 
 
14668 
  def write(self, oprot):
14669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14671 
      return
14672 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 14673 
    if self.success is not None:
2536 chandransh 14674 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14675 
      oprot.writeBool(self.success)
14676 
      oprot.writeFieldEnd()
3431 rajveer 14677 
    if self.ex is not None:
2536 chandransh 14678 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14679 
      self.ex.write(oprot)
14680 
      oprot.writeFieldEnd()
14681 
    oprot.writeFieldStop()
14682 
    oprot.writeStructEnd()
14683 
 
3431 rajveer 14684 
  def validate(self):
14685 
    return
14686 
 
14687 
 
2536 chandransh 14688 
  def __repr__(self):
14689 
    L = ['%s=%r' % (key, value)
14690 
      for key, value in self.__dict__.iteritems()]
14691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14692 
 
14693 
  def __eq__(self, other):
14694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14695 
 
14696 
  def __ne__(self, other):
14697 
    return not (self == other)
14698 
 
14699 
class authorizePickup_args:
14700 
  """
14701 
  Attributes:
14702 
   - orderId
14703 
   - pickupNumber
4602 rajveer 14704 
   - providerId
2536 chandransh 14705 
  """
14706 
 
14707 
  thrift_spec = (
14708 
    None, # 0
14709 
    (1, TType.I64, 'orderId', None, None, ), # 1
14710 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 14711 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 14712 
  )
14713 
 
4602 rajveer 14714 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 14715 
    self.orderId = orderId
14716 
    self.pickupNumber = pickupNumber
4602 rajveer 14717 
    self.providerId = providerId
2536 chandransh 14718 
 
14719 
  def read(self, iprot):
14720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14722 
      return
14723 
    iprot.readStructBegin()
14724 
    while True:
14725 
      (fname, ftype, fid) = iprot.readFieldBegin()
14726 
      if ftype == TType.STOP:
14727 
        break
14728 
      if fid == 1:
14729 
        if ftype == TType.I64:
14730 
          self.orderId = iprot.readI64();
14731 
        else:
14732 
          iprot.skip(ftype)
14733 
      elif fid == 2:
14734 
        if ftype == TType.STRING:
14735 
          self.pickupNumber = iprot.readString();
14736 
        else:
14737 
          iprot.skip(ftype)
4602 rajveer 14738 
      elif fid == 3:
14739 
        if ftype == TType.I64:
14740 
          self.providerId = iprot.readI64();
14741 
        else:
14742 
          iprot.skip(ftype)
2536 chandransh 14743 
      else:
14744 
        iprot.skip(ftype)
14745 
      iprot.readFieldEnd()
14746 
    iprot.readStructEnd()
14747 
 
14748 
  def write(self, oprot):
14749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14751 
      return
14752 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 14753 
    if self.orderId is not None:
2536 chandransh 14754 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14755 
      oprot.writeI64(self.orderId)
14756 
      oprot.writeFieldEnd()
3431 rajveer 14757 
    if self.pickupNumber is not None:
2536 chandransh 14758 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
14759 
      oprot.writeString(self.pickupNumber)
14760 
      oprot.writeFieldEnd()
4602 rajveer 14761 
    if self.providerId is not None:
14762 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
14763 
      oprot.writeI64(self.providerId)
14764 
      oprot.writeFieldEnd()
2536 chandransh 14765 
    oprot.writeFieldStop()
14766 
    oprot.writeStructEnd()
14767 
 
3431 rajveer 14768 
  def validate(self):
14769 
    return
14770 
 
14771 
 
2536 chandransh 14772 
  def __repr__(self):
14773 
    L = ['%s=%r' % (key, value)
14774 
      for key, value in self.__dict__.iteritems()]
14775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14776 
 
14777 
  def __eq__(self, other):
14778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14779 
 
14780 
  def __ne__(self, other):
14781 
    return not (self == other)
14782 
 
14783 
class authorizePickup_result:
14784 
  """
14785 
  Attributes:
14786 
   - success
14787 
   - ex
14788 
  """
14789 
 
14790 
  thrift_spec = (
14791 
    (0, TType.BOOL, 'success', None, None, ), # 0
14792 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14793 
  )
14794 
 
14795 
  def __init__(self, success=None, ex=None,):
14796 
    self.success = success
14797 
    self.ex = ex
14798 
 
14799 
  def read(self, iprot):
14800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14802 
      return
14803 
    iprot.readStructBegin()
14804 
    while True:
14805 
      (fname, ftype, fid) = iprot.readFieldBegin()
14806 
      if ftype == TType.STOP:
14807 
        break
14808 
      if fid == 0:
14809 
        if ftype == TType.BOOL:
14810 
          self.success = iprot.readBool();
14811 
        else:
14812 
          iprot.skip(ftype)
14813 
      elif fid == 1:
14814 
        if ftype == TType.STRUCT:
14815 
          self.ex = TransactionServiceException()
14816 
          self.ex.read(iprot)
14817 
        else:
14818 
          iprot.skip(ftype)
14819 
      else:
14820 
        iprot.skip(ftype)
14821 
      iprot.readFieldEnd()
14822 
    iprot.readStructEnd()
14823 
 
14824 
  def write(self, oprot):
14825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14827 
      return
14828 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 14829 
    if self.success is not None:
2536 chandransh 14830 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14831 
      oprot.writeBool(self.success)
14832 
      oprot.writeFieldEnd()
3431 rajveer 14833 
    if self.ex is not None:
2536 chandransh 14834 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14835 
      self.ex.write(oprot)
14836 
      oprot.writeFieldEnd()
14837 
    oprot.writeFieldStop()
14838 
    oprot.writeStructEnd()
14839 
 
3431 rajveer 14840 
  def validate(self):
14841 
    return
14842 
 
14843 
 
2536 chandransh 14844 
  def __repr__(self):
14845 
    L = ['%s=%r' % (key, value)
14846 
      for key, value in self.__dict__.iteritems()]
14847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14848 
 
14849 
  def __eq__(self, other):
14850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14851 
 
14852 
  def __ne__(self, other):
14853 
    return not (self == other)
14854 
 
2764 chandransh 14855 
class markDoasAsPickedUp_args:
14856 
  """
14857 
  Attributes:
14858 
   - providerId
14859 
   - pickupDetails
14860 
  """
14861 
 
14862 
  thrift_spec = (
14863 
    None, # 0
14864 
    (1, TType.I64, 'providerId', None, None, ), # 1
14865 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
14866 
  )
14867 
 
14868 
  def __init__(self, providerId=None, pickupDetails=None,):
14869 
    self.providerId = providerId
14870 
    self.pickupDetails = pickupDetails
14871 
 
14872 
  def read(self, iprot):
14873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14875 
      return
14876 
    iprot.readStructBegin()
14877 
    while True:
14878 
      (fname, ftype, fid) = iprot.readFieldBegin()
14879 
      if ftype == TType.STOP:
14880 
        break
14881 
      if fid == 1:
14882 
        if ftype == TType.I64:
14883 
          self.providerId = iprot.readI64();
14884 
        else:
14885 
          iprot.skip(ftype)
14886 
      elif fid == 2:
14887 
        if ftype == TType.MAP:
14888 
          self.pickupDetails = {}
5031 varun.gupt 14889 
          (_ktype323, _vtype324, _size322 ) = iprot.readMapBegin()
14890 
          for _i326 in xrange(_size322):
14891 
            _key327 = iprot.readString();
14892 
            _val328 = iprot.readString();
14893 
            self.pickupDetails[_key327] = _val328
2764 chandransh 14894 
          iprot.readMapEnd()
14895 
        else:
14896 
          iprot.skip(ftype)
14897 
      else:
14898 
        iprot.skip(ftype)
14899 
      iprot.readFieldEnd()
14900 
    iprot.readStructEnd()
14901 
 
14902 
  def write(self, oprot):
14903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14905 
      return
14906 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 14907 
    if self.providerId is not None:
2764 chandransh 14908 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14909 
      oprot.writeI64(self.providerId)
14910 
      oprot.writeFieldEnd()
3431 rajveer 14911 
    if self.pickupDetails is not None:
2764 chandransh 14912 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14913 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 14914 
      for kiter329,viter330 in self.pickupDetails.items():
14915 
        oprot.writeString(kiter329)
14916 
        oprot.writeString(viter330)
2764 chandransh 14917 
      oprot.writeMapEnd()
14918 
      oprot.writeFieldEnd()
14919 
    oprot.writeFieldStop()
14920 
    oprot.writeStructEnd()
14921 
 
3431 rajveer 14922 
  def validate(self):
14923 
    return
14924 
 
14925 
 
2764 chandransh 14926 
  def __repr__(self):
14927 
    L = ['%s=%r' % (key, value)
14928 
      for key, value in self.__dict__.iteritems()]
14929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14930 
 
14931 
  def __eq__(self, other):
14932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14933 
 
14934 
  def __ne__(self, other):
14935 
    return not (self == other)
14936 
 
14937 
class markDoasAsPickedUp_result:
4910 phani.kuma 14938 
 
14939 
  thrift_spec = (
14940 
  )
14941 
 
14942 
  def read(self, iprot):
14943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14945 
      return
14946 
    iprot.readStructBegin()
14947 
    while True:
14948 
      (fname, ftype, fid) = iprot.readFieldBegin()
14949 
      if ftype == TType.STOP:
14950 
        break
14951 
      else:
14952 
        iprot.skip(ftype)
14953 
      iprot.readFieldEnd()
14954 
    iprot.readStructEnd()
14955 
 
14956 
  def write(self, oprot):
14957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14959 
      return
14960 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
14961 
    oprot.writeFieldStop()
14962 
    oprot.writeStructEnd()
14963 
 
14964 
  def validate(self):
14965 
    return
14966 
 
14967 
 
14968 
  def __repr__(self):
14969 
    L = ['%s=%r' % (key, value)
14970 
      for key, value in self.__dict__.iteritems()]
14971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14972 
 
14973 
  def __eq__(self, other):
14974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14975 
 
14976 
  def __ne__(self, other):
14977 
    return not (self == other)
14978 
 
14979 
class getDoasNotPickedUp_args:
2764 chandransh 14980 
  """
14981 
  Attributes:
4910 phani.kuma 14982 
   - providerId
14983 
  """
14984 
 
14985 
  thrift_spec = (
14986 
    None, # 0
14987 
    (1, TType.I64, 'providerId', None, None, ), # 1
14988 
  )
14989 
 
14990 
  def __init__(self, providerId=None,):
14991 
    self.providerId = providerId
14992 
 
14993 
  def read(self, iprot):
14994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14996 
      return
14997 
    iprot.readStructBegin()
14998 
    while True:
14999 
      (fname, ftype, fid) = iprot.readFieldBegin()
15000 
      if ftype == TType.STOP:
15001 
        break
15002 
      if fid == 1:
15003 
        if ftype == TType.I64:
15004 
          self.providerId = iprot.readI64();
15005 
        else:
15006 
          iprot.skip(ftype)
15007 
      else:
15008 
        iprot.skip(ftype)
15009 
      iprot.readFieldEnd()
15010 
    iprot.readStructEnd()
15011 
 
15012 
  def write(self, oprot):
15013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15015 
      return
15016 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
15017 
    if self.providerId is not None:
15018 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15019 
      oprot.writeI64(self.providerId)
15020 
      oprot.writeFieldEnd()
15021 
    oprot.writeFieldStop()
15022 
    oprot.writeStructEnd()
15023 
 
15024 
  def validate(self):
15025 
    return
15026 
 
15027 
 
15028 
  def __repr__(self):
15029 
    L = ['%s=%r' % (key, value)
15030 
      for key, value in self.__dict__.iteritems()]
15031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15032 
 
15033 
  def __eq__(self, other):
15034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15035 
 
15036 
  def __ne__(self, other):
15037 
    return not (self == other)
15038 
 
15039 
class getDoasNotPickedUp_result:
15040 
  """
15041 
  Attributes:
2764 chandransh 15042 
   - success
15043 
  """
15044 
 
15045 
  thrift_spec = (
15046 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15047 
  )
15048 
 
15049 
  def __init__(self, success=None,):
15050 
    self.success = success
15051 
 
15052 
  def read(self, iprot):
15053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15055 
      return
15056 
    iprot.readStructBegin()
15057 
    while True:
15058 
      (fname, ftype, fid) = iprot.readFieldBegin()
15059 
      if ftype == TType.STOP:
15060 
        break
15061 
      if fid == 0:
15062 
        if ftype == TType.LIST:
15063 
          self.success = []
5031 varun.gupt 15064 
          (_etype334, _size331) = iprot.readListBegin()
15065 
          for _i335 in xrange(_size331):
15066 
            _elem336 = Order()
15067 
            _elem336.read(iprot)
15068 
            self.success.append(_elem336)
2764 chandransh 15069 
          iprot.readListEnd()
15070 
        else:
15071 
          iprot.skip(ftype)
15072 
      else:
15073 
        iprot.skip(ftype)
15074 
      iprot.readFieldEnd()
15075 
    iprot.readStructEnd()
15076 
 
15077 
  def write(self, oprot):
15078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15080 
      return
4910 phani.kuma 15081 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 15082 
    if self.success is not None:
2764 chandransh 15083 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15084 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 15085 
      for iter337 in self.success:
15086 
        iter337.write(oprot)
2764 chandransh 15087 
      oprot.writeListEnd()
15088 
      oprot.writeFieldEnd()
15089 
    oprot.writeFieldStop()
15090 
    oprot.writeStructEnd()
15091 
 
3431 rajveer 15092 
  def validate(self):
15093 
    return
15094 
 
15095 
 
2764 chandransh 15096 
  def __repr__(self):
15097 
    L = ['%s=%r' % (key, value)
15098 
      for key, value in self.__dict__.iteritems()]
15099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15100 
 
15101 
  def __eq__(self, other):
15102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15103 
 
15104 
  def __ne__(self, other):
15105 
    return not (self == other)
15106 
 
4741 phani.kuma 15107 
class markReturnOrdersAsPickedUp_args:
15108 
  """
15109 
  Attributes:
15110 
   - providerId
15111 
   - pickupDetails
15112 
  """
15113 
 
15114 
  thrift_spec = (
15115 
    None, # 0
15116 
    (1, TType.I64, 'providerId', None, None, ), # 1
15117 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
15118 
  )
15119 
 
15120 
  def __init__(self, providerId=None, pickupDetails=None,):
15121 
    self.providerId = providerId
15122 
    self.pickupDetails = pickupDetails
15123 
 
15124 
  def read(self, iprot):
15125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15127 
      return
15128 
    iprot.readStructBegin()
15129 
    while True:
15130 
      (fname, ftype, fid) = iprot.readFieldBegin()
15131 
      if ftype == TType.STOP:
15132 
        break
15133 
      if fid == 1:
15134 
        if ftype == TType.I64:
15135 
          self.providerId = iprot.readI64();
15136 
        else:
15137 
          iprot.skip(ftype)
15138 
      elif fid == 2:
15139 
        if ftype == TType.MAP:
15140 
          self.pickupDetails = {}
5031 varun.gupt 15141 
          (_ktype339, _vtype340, _size338 ) = iprot.readMapBegin()
15142 
          for _i342 in xrange(_size338):
15143 
            _key343 = iprot.readString();
15144 
            _val344 = iprot.readString();
15145 
            self.pickupDetails[_key343] = _val344
4741 phani.kuma 15146 
          iprot.readMapEnd()
15147 
        else:
15148 
          iprot.skip(ftype)
15149 
      else:
15150 
        iprot.skip(ftype)
15151 
      iprot.readFieldEnd()
15152 
    iprot.readStructEnd()
15153 
 
15154 
  def write(self, oprot):
15155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15157 
      return
15158 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
15159 
    if self.providerId is not None:
15160 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15161 
      oprot.writeI64(self.providerId)
15162 
      oprot.writeFieldEnd()
15163 
    if self.pickupDetails is not None:
15164 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15165 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 15166 
      for kiter345,viter346 in self.pickupDetails.items():
15167 
        oprot.writeString(kiter345)
15168 
        oprot.writeString(viter346)
4741 phani.kuma 15169 
      oprot.writeMapEnd()
15170 
      oprot.writeFieldEnd()
15171 
    oprot.writeFieldStop()
15172 
    oprot.writeStructEnd()
15173 
 
15174 
  def validate(self):
15175 
    return
15176 
 
15177 
 
15178 
  def __repr__(self):
15179 
    L = ['%s=%r' % (key, value)
15180 
      for key, value in self.__dict__.iteritems()]
15181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15182 
 
15183 
  def __eq__(self, other):
15184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15185 
 
15186 
  def __ne__(self, other):
15187 
    return not (self == other)
15188 
 
15189 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 15190 
 
15191 
  thrift_spec = (
15192 
  )
15193 
 
15194 
  def read(self, iprot):
15195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15197 
      return
15198 
    iprot.readStructBegin()
15199 
    while True:
15200 
      (fname, ftype, fid) = iprot.readFieldBegin()
15201 
      if ftype == TType.STOP:
15202 
        break
15203 
      else:
15204 
        iprot.skip(ftype)
15205 
      iprot.readFieldEnd()
15206 
    iprot.readStructEnd()
15207 
 
15208 
  def write(self, oprot):
15209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15211 
      return
15212 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
15213 
    oprot.writeFieldStop()
15214 
    oprot.writeStructEnd()
15215 
 
15216 
  def validate(self):
15217 
    return
15218 
 
15219 
 
15220 
  def __repr__(self):
15221 
    L = ['%s=%r' % (key, value)
15222 
      for key, value in self.__dict__.iteritems()]
15223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15224 
 
15225 
  def __eq__(self, other):
15226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15227 
 
15228 
  def __ne__(self, other):
15229 
    return not (self == other)
15230 
 
15231 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 15232 
  """
15233 
  Attributes:
4910 phani.kuma 15234 
   - providerId
15235 
  """
15236 
 
15237 
  thrift_spec = (
15238 
    None, # 0
15239 
    (1, TType.I64, 'providerId', None, None, ), # 1
15240 
  )
15241 
 
15242 
  def __init__(self, providerId=None,):
15243 
    self.providerId = providerId
15244 
 
15245 
  def read(self, iprot):
15246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15248 
      return
15249 
    iprot.readStructBegin()
15250 
    while True:
15251 
      (fname, ftype, fid) = iprot.readFieldBegin()
15252 
      if ftype == TType.STOP:
15253 
        break
15254 
      if fid == 1:
15255 
        if ftype == TType.I64:
15256 
          self.providerId = iprot.readI64();
15257 
        else:
15258 
          iprot.skip(ftype)
15259 
      else:
15260 
        iprot.skip(ftype)
15261 
      iprot.readFieldEnd()
15262 
    iprot.readStructEnd()
15263 
 
15264 
  def write(self, oprot):
15265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15267 
      return
15268 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
15269 
    if self.providerId is not None:
15270 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15271 
      oprot.writeI64(self.providerId)
15272 
      oprot.writeFieldEnd()
15273 
    oprot.writeFieldStop()
15274 
    oprot.writeStructEnd()
15275 
 
15276 
  def validate(self):
15277 
    return
15278 
 
15279 
 
15280 
  def __repr__(self):
15281 
    L = ['%s=%r' % (key, value)
15282 
      for key, value in self.__dict__.iteritems()]
15283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15284 
 
15285 
  def __eq__(self, other):
15286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15287 
 
15288 
  def __ne__(self, other):
15289 
    return not (self == other)
15290 
 
15291 
class getReturnOrdersNotPickedUp_result:
15292 
  """
15293 
  Attributes:
4741 phani.kuma 15294 
   - success
15295 
  """
15296 
 
15297 
  thrift_spec = (
15298 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15299 
  )
15300 
 
15301 
  def __init__(self, success=None,):
15302 
    self.success = success
15303 
 
15304 
  def read(self, iprot):
15305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15307 
      return
15308 
    iprot.readStructBegin()
15309 
    while True:
15310 
      (fname, ftype, fid) = iprot.readFieldBegin()
15311 
      if ftype == TType.STOP:
15312 
        break
15313 
      if fid == 0:
15314 
        if ftype == TType.LIST:
15315 
          self.success = []
5031 varun.gupt 15316 
          (_etype350, _size347) = iprot.readListBegin()
15317 
          for _i351 in xrange(_size347):
15318 
            _elem352 = Order()
15319 
            _elem352.read(iprot)
15320 
            self.success.append(_elem352)
4741 phani.kuma 15321 
          iprot.readListEnd()
15322 
        else:
15323 
          iprot.skip(ftype)
15324 
      else:
15325 
        iprot.skip(ftype)
15326 
      iprot.readFieldEnd()
15327 
    iprot.readStructEnd()
15328 
 
15329 
  def write(self, oprot):
15330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15332 
      return
4910 phani.kuma 15333 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 15334 
    if self.success is not None:
15335 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15336 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 15337 
      for iter353 in self.success:
15338 
        iter353.write(oprot)
4741 phani.kuma 15339 
      oprot.writeListEnd()
15340 
      oprot.writeFieldEnd()
15341 
    oprot.writeFieldStop()
15342 
    oprot.writeStructEnd()
15343 
 
15344 
  def validate(self):
15345 
    return
15346 
 
15347 
 
15348 
  def __repr__(self):
15349 
    L = ['%s=%r' % (key, value)
15350 
      for key, value in self.__dict__.iteritems()]
15351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15352 
 
15353 
  def __eq__(self, other):
15354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15355 
 
15356 
  def __ne__(self, other):
15357 
    return not (self == other)
15358 
 
2616 chandransh 15359 
class receiveReturn_args:
2591 chandransh 15360 
  """
15361 
  Attributes:
15362 
   - orderId
4479 rajveer 15363 
   - receiveCondition
2591 chandransh 15364 
  """
2536 chandransh 15365 
 
2591 chandransh 15366 
  thrift_spec = (
15367 
    None, # 0
15368 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 15369 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 15370 
  )
15371 
 
4479 rajveer 15372 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 15373 
    self.orderId = orderId
4479 rajveer 15374 
    self.receiveCondition = receiveCondition
2591 chandransh 15375 
 
15376 
  def read(self, iprot):
15377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15379 
      return
15380 
    iprot.readStructBegin()
15381 
    while True:
15382 
      (fname, ftype, fid) = iprot.readFieldBegin()
15383 
      if ftype == TType.STOP:
15384 
        break
15385 
      if fid == 1:
15386 
        if ftype == TType.I64:
15387 
          self.orderId = iprot.readI64();
15388 
        else:
15389 
          iprot.skip(ftype)
4479 rajveer 15390 
      elif fid == 2:
15391 
        if ftype == TType.I64:
15392 
          self.receiveCondition = iprot.readI64();
15393 
        else:
15394 
          iprot.skip(ftype)
2591 chandransh 15395 
      else:
15396 
        iprot.skip(ftype)
15397 
      iprot.readFieldEnd()
15398 
    iprot.readStructEnd()
15399 
 
15400 
  def write(self, oprot):
15401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15403 
      return
2616 chandransh 15404 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 15405 
    if self.orderId is not None:
2591 chandransh 15406 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15407 
      oprot.writeI64(self.orderId)
15408 
      oprot.writeFieldEnd()
4479 rajveer 15409 
    if self.receiveCondition is not None:
15410 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
15411 
      oprot.writeI64(self.receiveCondition)
15412 
      oprot.writeFieldEnd()
2591 chandransh 15413 
    oprot.writeFieldStop()
15414 
    oprot.writeStructEnd()
15415 
 
3431 rajveer 15416 
  def validate(self):
15417 
    return
15418 
 
15419 
 
2591 chandransh 15420 
  def __repr__(self):
15421 
    L = ['%s=%r' % (key, value)
15422 
      for key, value in self.__dict__.iteritems()]
15423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15424 
 
15425 
  def __eq__(self, other):
15426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15427 
 
15428 
  def __ne__(self, other):
15429 
    return not (self == other)
15430 
 
2616 chandransh 15431 
class receiveReturn_result:
2591 chandransh 15432 
  """
15433 
  Attributes:
15434 
   - success
15435 
   - ex
15436 
  """
15437 
 
15438 
  thrift_spec = (
15439 
    (0, TType.BOOL, 'success', None, None, ), # 0
15440 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15441 
  )
15442 
 
15443 
  def __init__(self, success=None, ex=None,):
15444 
    self.success = success
15445 
    self.ex = ex
15446 
 
15447 
  def read(self, iprot):
15448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15450 
      return
15451 
    iprot.readStructBegin()
15452 
    while True:
15453 
      (fname, ftype, fid) = iprot.readFieldBegin()
15454 
      if ftype == TType.STOP:
15455 
        break
15456 
      if fid == 0:
15457 
        if ftype == TType.BOOL:
15458 
          self.success = iprot.readBool();
15459 
        else:
15460 
          iprot.skip(ftype)
15461 
      elif fid == 1:
15462 
        if ftype == TType.STRUCT:
15463 
          self.ex = TransactionServiceException()
15464 
          self.ex.read(iprot)
15465 
        else:
15466 
          iprot.skip(ftype)
15467 
      else:
15468 
        iprot.skip(ftype)
15469 
      iprot.readFieldEnd()
15470 
    iprot.readStructEnd()
15471 
 
15472 
  def write(self, oprot):
15473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15475 
      return
2616 chandransh 15476 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 15477 
    if self.success is not None:
2591 chandransh 15478 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15479 
      oprot.writeBool(self.success)
15480 
      oprot.writeFieldEnd()
3431 rajveer 15481 
    if self.ex is not None:
2591 chandransh 15482 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15483 
      self.ex.write(oprot)
15484 
      oprot.writeFieldEnd()
15485 
    oprot.writeFieldStop()
15486 
    oprot.writeStructEnd()
15487 
 
3431 rajveer 15488 
  def validate(self):
15489 
    return
15490 
 
15491 
 
2591 chandransh 15492 
  def __repr__(self):
15493 
    L = ['%s=%r' % (key, value)
15494 
      for key, value in self.__dict__.iteritems()]
15495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15496 
 
15497 
  def __eq__(self, other):
15498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15499 
 
15500 
  def __ne__(self, other):
15501 
    return not (self == other)
15502 
 
15503 
class validateDoa_args:
15504 
  """
15505 
  Attributes:
15506 
   - orderId
15507 
   - isValid
15508 
  """
15509 
 
15510 
  thrift_spec = (
15511 
    None, # 0
15512 
    (1, TType.I64, 'orderId', None, None, ), # 1
15513 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
15514 
  )
15515 
 
15516 
  def __init__(self, orderId=None, isValid=None,):
15517 
    self.orderId = orderId
15518 
    self.isValid = isValid
15519 
 
15520 
  def read(self, iprot):
15521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15523 
      return
15524 
    iprot.readStructBegin()
15525 
    while True:
15526 
      (fname, ftype, fid) = iprot.readFieldBegin()
15527 
      if ftype == TType.STOP:
15528 
        break
15529 
      if fid == 1:
15530 
        if ftype == TType.I64:
15531 
          self.orderId = iprot.readI64();
15532 
        else:
15533 
          iprot.skip(ftype)
15534 
      elif fid == 2:
15535 
        if ftype == TType.BOOL:
15536 
          self.isValid = iprot.readBool();
15537 
        else:
15538 
          iprot.skip(ftype)
15539 
      else:
15540 
        iprot.skip(ftype)
15541 
      iprot.readFieldEnd()
15542 
    iprot.readStructEnd()
15543 
 
15544 
  def write(self, oprot):
15545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15547 
      return
15548 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 15549 
    if self.orderId is not None:
2591 chandransh 15550 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15551 
      oprot.writeI64(self.orderId)
15552 
      oprot.writeFieldEnd()
3431 rajveer 15553 
    if self.isValid is not None:
2591 chandransh 15554 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
15555 
      oprot.writeBool(self.isValid)
15556 
      oprot.writeFieldEnd()
15557 
    oprot.writeFieldStop()
15558 
    oprot.writeStructEnd()
15559 
 
3431 rajveer 15560 
  def validate(self):
15561 
    return
15562 
 
15563 
 
2591 chandransh 15564 
  def __repr__(self):
15565 
    L = ['%s=%r' % (key, value)
15566 
      for key, value in self.__dict__.iteritems()]
15567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15568 
 
15569 
  def __eq__(self, other):
15570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15571 
 
15572 
  def __ne__(self, other):
15573 
    return not (self == other)
15574 
 
15575 
class validateDoa_result:
15576 
  """
15577 
  Attributes:
15578 
   - success
15579 
   - ex
15580 
  """
15581 
 
15582 
  thrift_spec = (
15583 
    (0, TType.BOOL, 'success', None, None, ), # 0
15584 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15585 
  )
15586 
 
15587 
  def __init__(self, success=None, ex=None,):
15588 
    self.success = success
15589 
    self.ex = ex
15590 
 
15591 
  def read(self, iprot):
15592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15594 
      return
15595 
    iprot.readStructBegin()
15596 
    while True:
15597 
      (fname, ftype, fid) = iprot.readFieldBegin()
15598 
      if ftype == TType.STOP:
15599 
        break
15600 
      if fid == 0:
15601 
        if ftype == TType.BOOL:
15602 
          self.success = iprot.readBool();
15603 
        else:
15604 
          iprot.skip(ftype)
15605 
      elif fid == 1:
15606 
        if ftype == TType.STRUCT:
15607 
          self.ex = TransactionServiceException()
15608 
          self.ex.read(iprot)
15609 
        else:
15610 
          iprot.skip(ftype)
15611 
      else:
15612 
        iprot.skip(ftype)
15613 
      iprot.readFieldEnd()
15614 
    iprot.readStructEnd()
15615 
 
15616 
  def write(self, oprot):
15617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15619 
      return
15620 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 15621 
    if self.success is not None:
2591 chandransh 15622 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15623 
      oprot.writeBool(self.success)
15624 
      oprot.writeFieldEnd()
3431 rajveer 15625 
    if self.ex is not None:
2591 chandransh 15626 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15627 
      self.ex.write(oprot)
15628 
      oprot.writeFieldEnd()
15629 
    oprot.writeFieldStop()
15630 
    oprot.writeStructEnd()
15631 
 
3431 rajveer 15632 
  def validate(self):
15633 
    return
15634 
 
15635 
 
2591 chandransh 15636 
  def __repr__(self):
15637 
    L = ['%s=%r' % (key, value)
15638 
      for key, value in self.__dict__.iteritems()]
15639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15640 
 
15641 
  def __eq__(self, other):
15642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15643 
 
15644 
  def __ne__(self, other):
15645 
    return not (self == other)
15646 
 
4495 rajveer 15647 
class validateReturnProduct_args:
15648 
  """
15649 
  Attributes:
15650 
   - orderId
15651 
   - isUsable
15652 
  """
15653 
 
15654 
  thrift_spec = (
15655 
    None, # 0
15656 
    (1, TType.I64, 'orderId', None, None, ), # 1
15657 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
15658 
  )
15659 
 
15660 
  def __init__(self, orderId=None, isUsable=None,):
15661 
    self.orderId = orderId
15662 
    self.isUsable = isUsable
15663 
 
15664 
  def read(self, iprot):
15665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15667 
      return
15668 
    iprot.readStructBegin()
15669 
    while True:
15670 
      (fname, ftype, fid) = iprot.readFieldBegin()
15671 
      if ftype == TType.STOP:
15672 
        break
15673 
      if fid == 1:
15674 
        if ftype == TType.I64:
15675 
          self.orderId = iprot.readI64();
15676 
        else:
15677 
          iprot.skip(ftype)
15678 
      elif fid == 2:
15679 
        if ftype == TType.BOOL:
15680 
          self.isUsable = iprot.readBool();
15681 
        else:
15682 
          iprot.skip(ftype)
15683 
      else:
15684 
        iprot.skip(ftype)
15685 
      iprot.readFieldEnd()
15686 
    iprot.readStructEnd()
15687 
 
15688 
  def write(self, oprot):
15689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15691 
      return
15692 
    oprot.writeStructBegin('validateReturnProduct_args')
15693 
    if self.orderId is not None:
15694 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15695 
      oprot.writeI64(self.orderId)
15696 
      oprot.writeFieldEnd()
15697 
    if self.isUsable is not None:
15698 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
15699 
      oprot.writeBool(self.isUsable)
15700 
      oprot.writeFieldEnd()
15701 
    oprot.writeFieldStop()
15702 
    oprot.writeStructEnd()
15703 
 
15704 
  def validate(self):
15705 
    return
15706 
 
15707 
 
15708 
  def __repr__(self):
15709 
    L = ['%s=%r' % (key, value)
15710 
      for key, value in self.__dict__.iteritems()]
15711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15712 
 
15713 
  def __eq__(self, other):
15714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15715 
 
15716 
  def __ne__(self, other):
15717 
    return not (self == other)
15718 
 
15719 
class validateReturnProduct_result:
15720 
  """
15721 
  Attributes:
15722 
   - success
15723 
   - ex
15724 
  """
15725 
 
15726 
  thrift_spec = (
15727 
    (0, TType.BOOL, 'success', None, None, ), # 0
15728 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15729 
  )
15730 
 
15731 
  def __init__(self, success=None, ex=None,):
15732 
    self.success = success
15733 
    self.ex = ex
15734 
 
15735 
  def read(self, iprot):
15736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15738 
      return
15739 
    iprot.readStructBegin()
15740 
    while True:
15741 
      (fname, ftype, fid) = iprot.readFieldBegin()
15742 
      if ftype == TType.STOP:
15743 
        break
15744 
      if fid == 0:
15745 
        if ftype == TType.BOOL:
15746 
          self.success = iprot.readBool();
15747 
        else:
15748 
          iprot.skip(ftype)
15749 
      elif fid == 1:
15750 
        if ftype == TType.STRUCT:
15751 
          self.ex = TransactionServiceException()
15752 
          self.ex.read(iprot)
15753 
        else:
15754 
          iprot.skip(ftype)
15755 
      else:
15756 
        iprot.skip(ftype)
15757 
      iprot.readFieldEnd()
15758 
    iprot.readStructEnd()
15759 
 
15760 
  def write(self, oprot):
15761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15763 
      return
15764 
    oprot.writeStructBegin('validateReturnProduct_result')
15765 
    if self.success is not None:
15766 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15767 
      oprot.writeBool(self.success)
15768 
      oprot.writeFieldEnd()
15769 
    if self.ex is not None:
15770 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15771 
      self.ex.write(oprot)
15772 
      oprot.writeFieldEnd()
15773 
    oprot.writeFieldStop()
15774 
    oprot.writeStructEnd()
15775 
 
15776 
  def validate(self):
15777 
    return
15778 
 
15779 
 
15780 
  def __repr__(self):
15781 
    L = ['%s=%r' % (key, value)
15782 
      for key, value in self.__dict__.iteritems()]
15783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15784 
 
15785 
  def __eq__(self, other):
15786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15787 
 
15788 
  def __ne__(self, other):
15789 
    return not (self == other)
15790 
 
2616 chandransh 15791 
class reshipOrder_args:
15792 
  """
15793 
  Attributes:
15794 
   - orderId
15795 
  """
2591 chandransh 15796 
 
2616 chandransh 15797 
  thrift_spec = (
15798 
    None, # 0
15799 
    (1, TType.I64, 'orderId', None, None, ), # 1
15800 
  )
15801 
 
15802 
  def __init__(self, orderId=None,):
15803 
    self.orderId = orderId
15804 
 
15805 
  def read(self, iprot):
15806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15808 
      return
15809 
    iprot.readStructBegin()
15810 
    while True:
15811 
      (fname, ftype, fid) = iprot.readFieldBegin()
15812 
      if ftype == TType.STOP:
15813 
        break
15814 
      if fid == 1:
15815 
        if ftype == TType.I64:
15816 
          self.orderId = iprot.readI64();
15817 
        else:
15818 
          iprot.skip(ftype)
15819 
      else:
15820 
        iprot.skip(ftype)
15821 
      iprot.readFieldEnd()
15822 
    iprot.readStructEnd()
15823 
 
15824 
  def write(self, oprot):
15825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15827 
      return
15828 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 15829 
    if self.orderId is not None:
2616 chandransh 15830 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15831 
      oprot.writeI64(self.orderId)
15832 
      oprot.writeFieldEnd()
15833 
    oprot.writeFieldStop()
15834 
    oprot.writeStructEnd()
15835 
 
3431 rajveer 15836 
  def validate(self):
15837 
    return
15838 
 
15839 
 
2616 chandransh 15840 
  def __repr__(self):
15841 
    L = ['%s=%r' % (key, value)
15842 
      for key, value in self.__dict__.iteritems()]
15843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15844 
 
15845 
  def __eq__(self, other):
15846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15847 
 
15848 
  def __ne__(self, other):
15849 
    return not (self == other)
15850 
 
15851 
class reshipOrder_result:
15852 
  """
15853 
  Attributes:
15854 
   - success
15855 
   - ex
15856 
  """
15857 
 
15858 
  thrift_spec = (
15859 
    (0, TType.I64, 'success', None, None, ), # 0
15860 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15861 
  )
15862 
 
15863 
  def __init__(self, success=None, ex=None,):
15864 
    self.success = success
15865 
    self.ex = ex
15866 
 
15867 
  def read(self, iprot):
15868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15870 
      return
15871 
    iprot.readStructBegin()
15872 
    while True:
15873 
      (fname, ftype, fid) = iprot.readFieldBegin()
15874 
      if ftype == TType.STOP:
15875 
        break
15876 
      if fid == 0:
15877 
        if ftype == TType.I64:
15878 
          self.success = iprot.readI64();
15879 
        else:
15880 
          iprot.skip(ftype)
15881 
      elif fid == 1:
15882 
        if ftype == TType.STRUCT:
15883 
          self.ex = TransactionServiceException()
15884 
          self.ex.read(iprot)
15885 
        else:
15886 
          iprot.skip(ftype)
15887 
      else:
15888 
        iprot.skip(ftype)
15889 
      iprot.readFieldEnd()
15890 
    iprot.readStructEnd()
15891 
 
15892 
  def write(self, oprot):
15893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15895 
      return
15896 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 15897 
    if self.success is not None:
2616 chandransh 15898 
      oprot.writeFieldBegin('success', TType.I64, 0)
15899 
      oprot.writeI64(self.success)
15900 
      oprot.writeFieldEnd()
3431 rajveer 15901 
    if self.ex is not None:
2616 chandransh 15902 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15903 
      self.ex.write(oprot)
15904 
      oprot.writeFieldEnd()
15905 
    oprot.writeFieldStop()
15906 
    oprot.writeStructEnd()
15907 
 
3431 rajveer 15908 
  def validate(self):
15909 
    return
15910 
 
15911 
 
2616 chandransh 15912 
  def __repr__(self):
15913 
    L = ['%s=%r' % (key, value)
15914 
      for key, value in self.__dict__.iteritems()]
15915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15916 
 
15917 
  def __eq__(self, other):
15918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15919 
 
15920 
  def __ne__(self, other):
15921 
    return not (self == other)
15922 
 
15923 
class refundOrder_args:
15924 
  """
15925 
  Attributes:
15926 
   - orderId
3226 chandransh 15927 
   - refundedBy
15928 
   - reason
2616 chandransh 15929 
  """
15930 
 
15931 
  thrift_spec = (
15932 
    None, # 0
15933 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 15934 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
15935 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 15936 
  )
15937 
 
3226 chandransh 15938 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 15939 
    self.orderId = orderId
3226 chandransh 15940 
    self.refundedBy = refundedBy
15941 
    self.reason = reason
2616 chandransh 15942 
 
15943 
  def read(self, iprot):
15944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15946 
      return
15947 
    iprot.readStructBegin()
15948 
    while True:
15949 
      (fname, ftype, fid) = iprot.readFieldBegin()
15950 
      if ftype == TType.STOP:
15951 
        break
15952 
      if fid == 1:
15953 
        if ftype == TType.I64:
15954 
          self.orderId = iprot.readI64();
15955 
        else:
15956 
          iprot.skip(ftype)
3226 chandransh 15957 
      elif fid == 2:
15958 
        if ftype == TType.STRING:
15959 
          self.refundedBy = iprot.readString();
15960 
        else:
15961 
          iprot.skip(ftype)
15962 
      elif fid == 3:
15963 
        if ftype == TType.STRING:
15964 
          self.reason = iprot.readString();
15965 
        else:
15966 
          iprot.skip(ftype)
2616 chandransh 15967 
      else:
15968 
        iprot.skip(ftype)
15969 
      iprot.readFieldEnd()
15970 
    iprot.readStructEnd()
15971 
 
15972 
  def write(self, oprot):
15973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15975 
      return
15976 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 15977 
    if self.orderId is not None:
2616 chandransh 15978 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15979 
      oprot.writeI64(self.orderId)
15980 
      oprot.writeFieldEnd()
3431 rajveer 15981 
    if self.refundedBy is not None:
3226 chandransh 15982 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
15983 
      oprot.writeString(self.refundedBy)
15984 
      oprot.writeFieldEnd()
3431 rajveer 15985 
    if self.reason is not None:
3226 chandransh 15986 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
15987 
      oprot.writeString(self.reason)
15988 
      oprot.writeFieldEnd()
2616 chandransh 15989 
    oprot.writeFieldStop()
15990 
    oprot.writeStructEnd()
15991 
 
3431 rajveer 15992 
  def validate(self):
15993 
    return
15994 
 
15995 
 
2616 chandransh 15996 
  def __repr__(self):
15997 
    L = ['%s=%r' % (key, value)
15998 
      for key, value in self.__dict__.iteritems()]
15999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16000 
 
16001 
  def __eq__(self, other):
16002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16003 
 
16004 
  def __ne__(self, other):
16005 
    return not (self == other)
16006 
 
16007 
class refundOrder_result:
16008 
  """
16009 
  Attributes:
16010 
   - success
16011 
   - ex
16012 
  """
16013 
 
16014 
  thrift_spec = (
16015 
    (0, TType.BOOL, 'success', None, None, ), # 0
16016 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16017 
  )
16018 
 
16019 
  def __init__(self, success=None, ex=None,):
16020 
    self.success = success
16021 
    self.ex = ex
16022 
 
16023 
  def read(self, iprot):
16024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16026 
      return
16027 
    iprot.readStructBegin()
16028 
    while True:
16029 
      (fname, ftype, fid) = iprot.readFieldBegin()
16030 
      if ftype == TType.STOP:
16031 
        break
16032 
      if fid == 0:
16033 
        if ftype == TType.BOOL:
16034 
          self.success = iprot.readBool();
16035 
        else:
16036 
          iprot.skip(ftype)
16037 
      elif fid == 1:
16038 
        if ftype == TType.STRUCT:
16039 
          self.ex = TransactionServiceException()
16040 
          self.ex.read(iprot)
16041 
        else:
16042 
          iprot.skip(ftype)
16043 
      else:
16044 
        iprot.skip(ftype)
16045 
      iprot.readFieldEnd()
16046 
    iprot.readStructEnd()
16047 
 
16048 
  def write(self, oprot):
16049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16051 
      return
16052 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 16053 
    if self.success is not None:
2616 chandransh 16054 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16055 
      oprot.writeBool(self.success)
16056 
      oprot.writeFieldEnd()
3431 rajveer 16057 
    if self.ex is not None:
2616 chandransh 16058 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16059 
      self.ex.write(oprot)
16060 
      oprot.writeFieldEnd()
16061 
    oprot.writeFieldStop()
16062 
    oprot.writeStructEnd()
16063 
 
3431 rajveer 16064 
  def validate(self):
16065 
    return
16066 
 
16067 
 
2616 chandransh 16068 
  def __repr__(self):
16069 
    L = ['%s=%r' % (key, value)
16070 
      for key, value in self.__dict__.iteritems()]
16071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16072 
 
16073 
  def __eq__(self, other):
16074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16075 
 
16076 
  def __ne__(self, other):
16077 
    return not (self == other)
16078 
 
2690 chandransh 16079 
class getReturnOrders_args:
16080 
  """
16081 
  Attributes:
16082 
   - warehouseId
16083 
   - fromDate
16084 
   - toDate
16085 
  """
2616 chandransh 16086 
 
2690 chandransh 16087 
  thrift_spec = (
16088 
    None, # 0
16089 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
16090 
    (2, TType.I64, 'fromDate', None, None, ), # 2
16091 
    (3, TType.I64, 'toDate', None, None, ), # 3
16092 
  )
16093 
 
16094 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
16095 
    self.warehouseId = warehouseId
16096 
    self.fromDate = fromDate
16097 
    self.toDate = toDate
16098 
 
16099 
  def read(self, iprot):
16100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16102 
      return
16103 
    iprot.readStructBegin()
16104 
    while True:
16105 
      (fname, ftype, fid) = iprot.readFieldBegin()
16106 
      if ftype == TType.STOP:
16107 
        break
16108 
      if fid == 1:
16109 
        if ftype == TType.I64:
16110 
          self.warehouseId = iprot.readI64();
16111 
        else:
16112 
          iprot.skip(ftype)
16113 
      elif fid == 2:
16114 
        if ftype == TType.I64:
16115 
          self.fromDate = iprot.readI64();
16116 
        else:
16117 
          iprot.skip(ftype)
16118 
      elif fid == 3:
16119 
        if ftype == TType.I64:
16120 
          self.toDate = iprot.readI64();
16121 
        else:
16122 
          iprot.skip(ftype)
16123 
      else:
16124 
        iprot.skip(ftype)
16125 
      iprot.readFieldEnd()
16126 
    iprot.readStructEnd()
16127 
 
16128 
  def write(self, oprot):
16129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16131 
      return
16132 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 16133 
    if self.warehouseId is not None:
2690 chandransh 16134 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
16135 
      oprot.writeI64(self.warehouseId)
16136 
      oprot.writeFieldEnd()
3431 rajveer 16137 
    if self.fromDate is not None:
2690 chandransh 16138 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
16139 
      oprot.writeI64(self.fromDate)
16140 
      oprot.writeFieldEnd()
3431 rajveer 16141 
    if self.toDate is not None:
2690 chandransh 16142 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
16143 
      oprot.writeI64(self.toDate)
16144 
      oprot.writeFieldEnd()
16145 
    oprot.writeFieldStop()
16146 
    oprot.writeStructEnd()
16147 
 
3431 rajveer 16148 
  def validate(self):
16149 
    return
16150 
 
16151 
 
2690 chandransh 16152 
  def __repr__(self):
16153 
    L = ['%s=%r' % (key, value)
16154 
      for key, value in self.__dict__.iteritems()]
16155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16156 
 
16157 
  def __eq__(self, other):
16158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16159 
 
16160 
  def __ne__(self, other):
16161 
    return not (self == other)
16162 
 
16163 
class getReturnOrders_result:
16164 
  """
16165 
  Attributes:
16166 
   - success
16167 
  """
16168 
 
16169 
  thrift_spec = (
16170 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
16171 
  )
16172 
 
16173 
  def __init__(self, success=None,):
16174 
    self.success = success
16175 
 
16176 
  def read(self, iprot):
16177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16179 
      return
16180 
    iprot.readStructBegin()
16181 
    while True:
16182 
      (fname, ftype, fid) = iprot.readFieldBegin()
16183 
      if ftype == TType.STOP:
16184 
        break
16185 
      if fid == 0:
16186 
        if ftype == TType.LIST:
16187 
          self.success = []
5031 varun.gupt 16188 
          (_etype357, _size354) = iprot.readListBegin()
16189 
          for _i358 in xrange(_size354):
16190 
            _elem359 = ReturnOrder()
16191 
            _elem359.read(iprot)
16192 
            self.success.append(_elem359)
2690 chandransh 16193 
          iprot.readListEnd()
16194 
        else:
16195 
          iprot.skip(ftype)
16196 
      else:
16197 
        iprot.skip(ftype)
16198 
      iprot.readFieldEnd()
16199 
    iprot.readStructEnd()
16200 
 
16201 
  def write(self, oprot):
16202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16204 
      return
16205 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 16206 
    if self.success is not None:
2690 chandransh 16207 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16208 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 16209 
      for iter360 in self.success:
16210 
        iter360.write(oprot)
2690 chandransh 16211 
      oprot.writeListEnd()
16212 
      oprot.writeFieldEnd()
16213 
    oprot.writeFieldStop()
16214 
    oprot.writeStructEnd()
16215 
 
3431 rajveer 16216 
  def validate(self):
16217 
    return
16218 
 
16219 
 
2690 chandransh 16220 
  def __repr__(self):
16221 
    L = ['%s=%r' % (key, value)
16222 
      for key, value in self.__dict__.iteritems()]
16223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16224 
 
16225 
  def __eq__(self, other):
16226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16227 
 
16228 
  def __ne__(self, other):
16229 
    return not (self == other)
16230 
 
2700 chandransh 16231 
class getReturnOrder_args:
16232 
  """
16233 
  Attributes:
16234 
   - id
16235 
  """
16236 
 
16237 
  thrift_spec = (
16238 
    None, # 0
16239 
    (1, TType.I64, 'id', None, None, ), # 1
16240 
  )
16241 
 
16242 
  def __init__(self, id=None,):
16243 
    self.id = id
16244 
 
16245 
  def read(self, iprot):
16246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16248 
      return
16249 
    iprot.readStructBegin()
16250 
    while True:
16251 
      (fname, ftype, fid) = iprot.readFieldBegin()
16252 
      if ftype == TType.STOP:
16253 
        break
16254 
      if fid == 1:
16255 
        if ftype == TType.I64:
16256 
          self.id = iprot.readI64();
16257 
        else:
16258 
          iprot.skip(ftype)
16259 
      else:
16260 
        iprot.skip(ftype)
16261 
      iprot.readFieldEnd()
16262 
    iprot.readStructEnd()
16263 
 
16264 
  def write(self, oprot):
16265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16267 
      return
16268 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 16269 
    if self.id is not None:
2700 chandransh 16270 
      oprot.writeFieldBegin('id', TType.I64, 1)
16271 
      oprot.writeI64(self.id)
16272 
      oprot.writeFieldEnd()
16273 
    oprot.writeFieldStop()
16274 
    oprot.writeStructEnd()
16275 
 
3431 rajveer 16276 
  def validate(self):
16277 
    return
16278 
 
16279 
 
2700 chandransh 16280 
  def __repr__(self):
16281 
    L = ['%s=%r' % (key, value)
16282 
      for key, value in self.__dict__.iteritems()]
16283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16284 
 
16285 
  def __eq__(self, other):
16286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16287 
 
16288 
  def __ne__(self, other):
16289 
    return not (self == other)
16290 
 
16291 
class getReturnOrder_result:
16292 
  """
16293 
  Attributes:
16294 
   - success
16295 
   - ex
16296 
  """
16297 
 
16298 
  thrift_spec = (
16299 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
16300 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16301 
  )
16302 
 
16303 
  def __init__(self, success=None, ex=None,):
16304 
    self.success = success
16305 
    self.ex = ex
16306 
 
16307 
  def read(self, iprot):
16308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16310 
      return
16311 
    iprot.readStructBegin()
16312 
    while True:
16313 
      (fname, ftype, fid) = iprot.readFieldBegin()
16314 
      if ftype == TType.STOP:
16315 
        break
16316 
      if fid == 0:
16317 
        if ftype == TType.STRUCT:
16318 
          self.success = ReturnOrder()
16319 
          self.success.read(iprot)
16320 
        else:
16321 
          iprot.skip(ftype)
16322 
      elif fid == 1:
16323 
        if ftype == TType.STRUCT:
16324 
          self.ex = TransactionServiceException()
16325 
          self.ex.read(iprot)
16326 
        else:
16327 
          iprot.skip(ftype)
16328 
      else:
16329 
        iprot.skip(ftype)
16330 
      iprot.readFieldEnd()
16331 
    iprot.readStructEnd()
16332 
 
16333 
  def write(self, oprot):
16334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16336 
      return
16337 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 16338 
    if self.success is not None:
2700 chandransh 16339 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16340 
      self.success.write(oprot)
16341 
      oprot.writeFieldEnd()
3431 rajveer 16342 
    if self.ex is not None:
2700 chandransh 16343 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16344 
      self.ex.write(oprot)
16345 
      oprot.writeFieldEnd()
16346 
    oprot.writeFieldStop()
16347 
    oprot.writeStructEnd()
16348 
 
3431 rajveer 16349 
  def validate(self):
16350 
    return
16351 
 
16352 
 
2700 chandransh 16353 
  def __repr__(self):
16354 
    L = ['%s=%r' % (key, value)
16355 
      for key, value in self.__dict__.iteritems()]
16356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16357 
 
16358 
  def __eq__(self, other):
16359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16360 
 
16361 
  def __ne__(self, other):
16362 
    return not (self == other)
16363 
 
2690 chandransh 16364 
class processReturn_args:
16365 
  """
16366 
  Attributes:
16367 
   - returnOrderId
16368 
  """
16369 
 
16370 
  thrift_spec = (
16371 
    None, # 0
16372 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
16373 
  )
16374 
 
16375 
  def __init__(self, returnOrderId=None,):
16376 
    self.returnOrderId = returnOrderId
16377 
 
16378 
  def read(self, iprot):
16379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16381 
      return
16382 
    iprot.readStructBegin()
16383 
    while True:
16384 
      (fname, ftype, fid) = iprot.readFieldBegin()
16385 
      if ftype == TType.STOP:
16386 
        break
16387 
      if fid == 1:
16388 
        if ftype == TType.I64:
16389 
          self.returnOrderId = iprot.readI64();
16390 
        else:
16391 
          iprot.skip(ftype)
16392 
      else:
16393 
        iprot.skip(ftype)
16394 
      iprot.readFieldEnd()
16395 
    iprot.readStructEnd()
16396 
 
16397 
  def write(self, oprot):
16398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16400 
      return
16401 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 16402 
    if self.returnOrderId is not None:
2690 chandransh 16403 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
16404 
      oprot.writeI64(self.returnOrderId)
16405 
      oprot.writeFieldEnd()
16406 
    oprot.writeFieldStop()
16407 
    oprot.writeStructEnd()
16408 
 
3431 rajveer 16409 
  def validate(self):
16410 
    return
16411 
 
16412 
 
2690 chandransh 16413 
  def __repr__(self):
16414 
    L = ['%s=%r' % (key, value)
16415 
      for key, value in self.__dict__.iteritems()]
16416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16417 
 
16418 
  def __eq__(self, other):
16419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16420 
 
16421 
  def __ne__(self, other):
16422 
    return not (self == other)
16423 
 
16424 
class processReturn_result:
16425 
  """
16426 
  Attributes:
16427 
   - ex
16428 
  """
16429 
 
16430 
  thrift_spec = (
16431 
    None, # 0
16432 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16433 
  )
16434 
 
16435 
  def __init__(self, ex=None,):
16436 
    self.ex = ex
16437 
 
16438 
  def read(self, iprot):
16439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16441 
      return
16442 
    iprot.readStructBegin()
16443 
    while True:
16444 
      (fname, ftype, fid) = iprot.readFieldBegin()
16445 
      if ftype == TType.STOP:
16446 
        break
16447 
      if fid == 1:
16448 
        if ftype == TType.STRUCT:
16449 
          self.ex = TransactionServiceException()
16450 
          self.ex.read(iprot)
16451 
        else:
16452 
          iprot.skip(ftype)
16453 
      else:
16454 
        iprot.skip(ftype)
16455 
      iprot.readFieldEnd()
16456 
    iprot.readStructEnd()
16457 
 
16458 
  def write(self, oprot):
16459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16461 
      return
16462 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 16463 
    if self.ex is not None:
2690 chandransh 16464 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16465 
      self.ex.write(oprot)
16466 
      oprot.writeFieldEnd()
16467 
    oprot.writeFieldStop()
16468 
    oprot.writeStructEnd()
16469 
 
3431 rajveer 16470 
  def validate(self):
16471 
    return
16472 
 
16473 
 
2690 chandransh 16474 
  def __repr__(self):
16475 
    L = ['%s=%r' % (key, value)
16476 
      for key, value in self.__dict__.iteritems()]
16477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16478 
 
16479 
  def __eq__(self, other):
16480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16481 
 
16482 
  def __ne__(self, other):
16483 
    return not (self == other)
16484 
 
3451 chandransh 16485 
class updateWeight_args:
16486 
  """
16487 
  Attributes:
16488 
   - orderId
16489 
   - weight
16490 
  """
16491 
 
16492 
  thrift_spec = (
16493 
    None, # 0
16494 
    (1, TType.I64, 'orderId', None, None, ), # 1
16495 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
16496 
  )
16497 
 
16498 
  def __init__(self, orderId=None, weight=None,):
16499 
    self.orderId = orderId
16500 
    self.weight = weight
16501 
 
16502 
  def read(self, iprot):
16503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16505 
      return
16506 
    iprot.readStructBegin()
16507 
    while True:
16508 
      (fname, ftype, fid) = iprot.readFieldBegin()
16509 
      if ftype == TType.STOP:
16510 
        break
16511 
      if fid == 1:
16512 
        if ftype == TType.I64:
16513 
          self.orderId = iprot.readI64();
16514 
        else:
16515 
          iprot.skip(ftype)
16516 
      elif fid == 2:
16517 
        if ftype == TType.DOUBLE:
16518 
          self.weight = iprot.readDouble();
16519 
        else:
16520 
          iprot.skip(ftype)
16521 
      else:
16522 
        iprot.skip(ftype)
16523 
      iprot.readFieldEnd()
16524 
    iprot.readStructEnd()
16525 
 
16526 
  def write(self, oprot):
16527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16529 
      return
16530 
    oprot.writeStructBegin('updateWeight_args')
16531 
    if self.orderId is not None:
16532 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16533 
      oprot.writeI64(self.orderId)
16534 
      oprot.writeFieldEnd()
16535 
    if self.weight is not None:
16536 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
16537 
      oprot.writeDouble(self.weight)
16538 
      oprot.writeFieldEnd()
16539 
    oprot.writeFieldStop()
16540 
    oprot.writeStructEnd()
16541 
 
16542 
  def validate(self):
16543 
    return
16544 
 
16545 
 
16546 
  def __repr__(self):
16547 
    L = ['%s=%r' % (key, value)
16548 
      for key, value in self.__dict__.iteritems()]
16549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16550 
 
16551 
  def __eq__(self, other):
16552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16553 
 
16554 
  def __ne__(self, other):
16555 
    return not (self == other)
16556 
 
16557 
class updateWeight_result:
16558 
  """
16559 
  Attributes:
16560 
   - success
16561 
   - ex
16562 
  """
16563 
 
16564 
  thrift_spec = (
16565 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16566 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16567 
  )
16568 
 
16569 
  def __init__(self, success=None, ex=None,):
16570 
    self.success = success
16571 
    self.ex = ex
16572 
 
16573 
  def read(self, iprot):
16574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16576 
      return
16577 
    iprot.readStructBegin()
16578 
    while True:
16579 
      (fname, ftype, fid) = iprot.readFieldBegin()
16580 
      if ftype == TType.STOP:
16581 
        break
16582 
      if fid == 0:
16583 
        if ftype == TType.STRUCT:
16584 
          self.success = Order()
16585 
          self.success.read(iprot)
16586 
        else:
16587 
          iprot.skip(ftype)
16588 
      elif fid == 1:
16589 
        if ftype == TType.STRUCT:
16590 
          self.ex = TransactionServiceException()
16591 
          self.ex.read(iprot)
16592 
        else:
16593 
          iprot.skip(ftype)
16594 
      else:
16595 
        iprot.skip(ftype)
16596 
      iprot.readFieldEnd()
16597 
    iprot.readStructEnd()
16598 
 
16599 
  def write(self, oprot):
16600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16602 
      return
16603 
    oprot.writeStructBegin('updateWeight_result')
16604 
    if self.success is not None:
16605 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16606 
      self.success.write(oprot)
16607 
      oprot.writeFieldEnd()
16608 
    if self.ex is not None:
16609 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16610 
      self.ex.write(oprot)
16611 
      oprot.writeFieldEnd()
16612 
    oprot.writeFieldStop()
16613 
    oprot.writeStructEnd()
16614 
 
16615 
  def validate(self):
16616 
    return
16617 
 
16618 
 
16619 
  def __repr__(self):
16620 
    L = ['%s=%r' % (key, value)
16621 
      for key, value in self.__dict__.iteritems()]
16622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16623 
 
16624 
  def __eq__(self, other):
16625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16626 
 
16627 
  def __ne__(self, other):
16628 
    return not (self == other)
3469 chandransh 16629 
 
16630 
class changeItem_args:
16631 
  """
16632 
  Attributes:
16633 
   - orderId
16634 
   - itemId
16635 
  """
16636 
 
16637 
  thrift_spec = (
16638 
    None, # 0
16639 
    (1, TType.I64, 'orderId', None, None, ), # 1
16640 
    (2, TType.I64, 'itemId', None, None, ), # 2
16641 
  )
16642 
 
16643 
  def __init__(self, orderId=None, itemId=None,):
16644 
    self.orderId = orderId
16645 
    self.itemId = itemId
16646 
 
16647 
  def read(self, iprot):
16648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16650 
      return
16651 
    iprot.readStructBegin()
16652 
    while True:
16653 
      (fname, ftype, fid) = iprot.readFieldBegin()
16654 
      if ftype == TType.STOP:
16655 
        break
16656 
      if fid == 1:
16657 
        if ftype == TType.I64:
16658 
          self.orderId = iprot.readI64();
16659 
        else:
16660 
          iprot.skip(ftype)
16661 
      elif fid == 2:
16662 
        if ftype == TType.I64:
16663 
          self.itemId = iprot.readI64();
16664 
        else:
16665 
          iprot.skip(ftype)
16666 
      else:
16667 
        iprot.skip(ftype)
16668 
      iprot.readFieldEnd()
16669 
    iprot.readStructEnd()
16670 
 
16671 
  def write(self, oprot):
16672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16674 
      return
16675 
    oprot.writeStructBegin('changeItem_args')
16676 
    if self.orderId is not None:
16677 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16678 
      oprot.writeI64(self.orderId)
16679 
      oprot.writeFieldEnd()
16680 
    if self.itemId is not None:
16681 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16682 
      oprot.writeI64(self.itemId)
16683 
      oprot.writeFieldEnd()
16684 
    oprot.writeFieldStop()
16685 
    oprot.writeStructEnd()
16686 
 
16687 
  def validate(self):
16688 
    return
16689 
 
16690 
 
16691 
  def __repr__(self):
16692 
    L = ['%s=%r' % (key, value)
16693 
      for key, value in self.__dict__.iteritems()]
16694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16695 
 
16696 
  def __eq__(self, other):
16697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16698 
 
16699 
  def __ne__(self, other):
16700 
    return not (self == other)
16701 
 
16702 
class changeItem_result:
16703 
  """
16704 
  Attributes:
16705 
   - success
16706 
   - ex
16707 
  """
16708 
 
16709 
  thrift_spec = (
16710 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16711 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16712 
  )
16713 
 
16714 
  def __init__(self, success=None, ex=None,):
16715 
    self.success = success
16716 
    self.ex = ex
16717 
 
16718 
  def read(self, iprot):
16719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16721 
      return
16722 
    iprot.readStructBegin()
16723 
    while True:
16724 
      (fname, ftype, fid) = iprot.readFieldBegin()
16725 
      if ftype == TType.STOP:
16726 
        break
16727 
      if fid == 0:
16728 
        if ftype == TType.STRUCT:
16729 
          self.success = Order()
16730 
          self.success.read(iprot)
16731 
        else:
16732 
          iprot.skip(ftype)
16733 
      elif fid == 1:
16734 
        if ftype == TType.STRUCT:
16735 
          self.ex = TransactionServiceException()
16736 
          self.ex.read(iprot)
16737 
        else:
16738 
          iprot.skip(ftype)
16739 
      else:
16740 
        iprot.skip(ftype)
16741 
      iprot.readFieldEnd()
16742 
    iprot.readStructEnd()
16743 
 
16744 
  def write(self, oprot):
16745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16747 
      return
16748 
    oprot.writeStructBegin('changeItem_result')
16749 
    if self.success is not None:
16750 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16751 
      self.success.write(oprot)
16752 
      oprot.writeFieldEnd()
16753 
    if self.ex is not None:
16754 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16755 
      self.ex.write(oprot)
16756 
      oprot.writeFieldEnd()
16757 
    oprot.writeFieldStop()
16758 
    oprot.writeStructEnd()
16759 
 
16760 
  def validate(self):
16761 
    return
16762 
 
16763 
 
16764 
  def __repr__(self):
16765 
    L = ['%s=%r' % (key, value)
16766 
      for key, value in self.__dict__.iteritems()]
16767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16768 
 
16769 
  def __eq__(self, other):
16770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16771 
 
16772 
  def __ne__(self, other):
16773 
    return not (self == other)
16774 
 
16775 
class shiftToWarehouse_args:
16776 
  """
16777 
  Attributes:
16778 
   - orderId
16779 
   - warehouseId
16780 
  """
16781 
 
16782 
  thrift_spec = (
16783 
    None, # 0
16784 
    (1, TType.I64, 'orderId', None, None, ), # 1
16785 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
16786 
  )
16787 
 
16788 
  def __init__(self, orderId=None, warehouseId=None,):
16789 
    self.orderId = orderId
16790 
    self.warehouseId = warehouseId
16791 
 
16792 
  def read(self, iprot):
16793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16795 
      return
16796 
    iprot.readStructBegin()
16797 
    while True:
16798 
      (fname, ftype, fid) = iprot.readFieldBegin()
16799 
      if ftype == TType.STOP:
16800 
        break
16801 
      if fid == 1:
16802 
        if ftype == TType.I64:
16803 
          self.orderId = iprot.readI64();
16804 
        else:
16805 
          iprot.skip(ftype)
16806 
      elif fid == 2:
16807 
        if ftype == TType.I64:
16808 
          self.warehouseId = iprot.readI64();
16809 
        else:
16810 
          iprot.skip(ftype)
16811 
      else:
16812 
        iprot.skip(ftype)
16813 
      iprot.readFieldEnd()
16814 
    iprot.readStructEnd()
16815 
 
16816 
  def write(self, oprot):
16817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16819 
      return
16820 
    oprot.writeStructBegin('shiftToWarehouse_args')
16821 
    if self.orderId is not None:
16822 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16823 
      oprot.writeI64(self.orderId)
16824 
      oprot.writeFieldEnd()
16825 
    if self.warehouseId is not None:
16826 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16827 
      oprot.writeI64(self.warehouseId)
16828 
      oprot.writeFieldEnd()
16829 
    oprot.writeFieldStop()
16830 
    oprot.writeStructEnd()
16831 
 
16832 
  def validate(self):
16833 
    return
16834 
 
16835 
 
16836 
  def __repr__(self):
16837 
    L = ['%s=%r' % (key, value)
16838 
      for key, value in self.__dict__.iteritems()]
16839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16840 
 
16841 
  def __eq__(self, other):
16842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16843 
 
16844 
  def __ne__(self, other):
16845 
    return not (self == other)
16846 
 
16847 
class shiftToWarehouse_result:
16848 
  """
16849 
  Attributes:
16850 
   - success
16851 
   - ex
16852 
  """
16853 
 
16854 
  thrift_spec = (
16855 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16856 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16857 
  )
16858 
 
16859 
  def __init__(self, success=None, ex=None,):
16860 
    self.success = success
16861 
    self.ex = ex
16862 
 
16863 
  def read(self, iprot):
16864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16866 
      return
16867 
    iprot.readStructBegin()
16868 
    while True:
16869 
      (fname, ftype, fid) = iprot.readFieldBegin()
16870 
      if ftype == TType.STOP:
16871 
        break
16872 
      if fid == 0:
16873 
        if ftype == TType.STRUCT:
16874 
          self.success = Order()
16875 
          self.success.read(iprot)
16876 
        else:
16877 
          iprot.skip(ftype)
16878 
      elif fid == 1:
16879 
        if ftype == TType.STRUCT:
16880 
          self.ex = TransactionServiceException()
16881 
          self.ex.read(iprot)
16882 
        else:
16883 
          iprot.skip(ftype)
16884 
      else:
16885 
        iprot.skip(ftype)
16886 
      iprot.readFieldEnd()
16887 
    iprot.readStructEnd()
16888 
 
16889 
  def write(self, oprot):
16890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16892 
      return
16893 
    oprot.writeStructBegin('shiftToWarehouse_result')
16894 
    if self.success is not None:
16895 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16896 
      self.success.write(oprot)
16897 
      oprot.writeFieldEnd()
16898 
    if self.ex is not None:
16899 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16900 
      self.ex.write(oprot)
16901 
      oprot.writeFieldEnd()
16902 
    oprot.writeFieldStop()
16903 
    oprot.writeStructEnd()
16904 
 
16905 
  def validate(self):
16906 
    return
16907 
 
16908 
 
16909 
  def __repr__(self):
16910 
    L = ['%s=%r' % (key, value)
16911 
      for key, value in self.__dict__.iteritems()]
16912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16913 
 
16914 
  def __eq__(self, other):
16915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16916 
 
16917 
  def __ne__(self, other):
16918 
    return not (self == other)
3553 chandransh 16919 
 
16920 
class addDelayReason_args:
16921 
  """
16922 
  Attributes:
16923 
   - orderId
16924 
   - delayReason
3986 chandransh 16925 
   - furtherDelay
4647 rajveer 16926 
   - delayReasonText
3553 chandransh 16927 
  """
16928 
 
16929 
  thrift_spec = (
16930 
    None, # 0
16931 
    (1, TType.I64, 'orderId', None, None, ), # 1
16932 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 16933 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 16934 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 16935 
  )
16936 
 
4647 rajveer 16937 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 16938 
    self.orderId = orderId
16939 
    self.delayReason = delayReason
3986 chandransh 16940 
    self.furtherDelay = furtherDelay
4647 rajveer 16941 
    self.delayReasonText = delayReasonText
3553 chandransh 16942 
 
16943 
  def read(self, iprot):
16944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16946 
      return
16947 
    iprot.readStructBegin()
16948 
    while True:
16949 
      (fname, ftype, fid) = iprot.readFieldBegin()
16950 
      if ftype == TType.STOP:
16951 
        break
16952 
      if fid == 1:
16953 
        if ftype == TType.I64:
16954 
          self.orderId = iprot.readI64();
16955 
        else:
16956 
          iprot.skip(ftype)
16957 
      elif fid == 2:
16958 
        if ftype == TType.I32:
16959 
          self.delayReason = iprot.readI32();
16960 
        else:
16961 
          iprot.skip(ftype)
3986 chandransh 16962 
      elif fid == 3:
16963 
        if ftype == TType.I64:
16964 
          self.furtherDelay = iprot.readI64();
16965 
        else:
16966 
          iprot.skip(ftype)
4647 rajveer 16967 
      elif fid == 4:
16968 
        if ftype == TType.STRING:
16969 
          self.delayReasonText = iprot.readString();
16970 
        else:
16971 
          iprot.skip(ftype)
3553 chandransh 16972 
      else:
16973 
        iprot.skip(ftype)
16974 
      iprot.readFieldEnd()
16975 
    iprot.readStructEnd()
16976 
 
16977 
  def write(self, oprot):
16978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16980 
      return
16981 
    oprot.writeStructBegin('addDelayReason_args')
16982 
    if self.orderId is not None:
16983 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16984 
      oprot.writeI64(self.orderId)
16985 
      oprot.writeFieldEnd()
16986 
    if self.delayReason is not None:
16987 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
16988 
      oprot.writeI32(self.delayReason)
16989 
      oprot.writeFieldEnd()
3986 chandransh 16990 
    if self.furtherDelay is not None:
16991 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
16992 
      oprot.writeI64(self.furtherDelay)
16993 
      oprot.writeFieldEnd()
4647 rajveer 16994 
    if self.delayReasonText is not None:
16995 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
16996 
      oprot.writeString(self.delayReasonText)
16997 
      oprot.writeFieldEnd()
3553 chandransh 16998 
    oprot.writeFieldStop()
16999 
    oprot.writeStructEnd()
17000 
 
17001 
  def validate(self):
17002 
    return
17003 
 
17004 
 
17005 
  def __repr__(self):
17006 
    L = ['%s=%r' % (key, value)
17007 
      for key, value in self.__dict__.iteritems()]
17008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17009 
 
17010 
  def __eq__(self, other):
17011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17012 
 
17013 
  def __ne__(self, other):
17014 
    return not (self == other)
17015 
 
17016 
class addDelayReason_result:
17017 
  """
17018 
  Attributes:
17019 
   - success
17020 
   - ex
17021 
  """
17022 
 
17023 
  thrift_spec = (
17024 
    (0, TType.BOOL, 'success', None, None, ), # 0
17025 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17026 
  )
17027 
 
17028 
  def __init__(self, success=None, ex=None,):
17029 
    self.success = success
17030 
    self.ex = ex
17031 
 
17032 
  def read(self, iprot):
17033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17035 
      return
17036 
    iprot.readStructBegin()
17037 
    while True:
17038 
      (fname, ftype, fid) = iprot.readFieldBegin()
17039 
      if ftype == TType.STOP:
17040 
        break
17041 
      if fid == 0:
17042 
        if ftype == TType.BOOL:
17043 
          self.success = iprot.readBool();
17044 
        else:
17045 
          iprot.skip(ftype)
17046 
      elif fid == 1:
17047 
        if ftype == TType.STRUCT:
17048 
          self.ex = TransactionServiceException()
17049 
          self.ex.read(iprot)
17050 
        else:
17051 
          iprot.skip(ftype)
17052 
      else:
17053 
        iprot.skip(ftype)
17054 
      iprot.readFieldEnd()
17055 
    iprot.readStructEnd()
17056 
 
17057 
  def write(self, oprot):
17058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17060 
      return
17061 
    oprot.writeStructBegin('addDelayReason_result')
17062 
    if self.success is not None:
17063 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17064 
      oprot.writeBool(self.success)
17065 
      oprot.writeFieldEnd()
17066 
    if self.ex is not None:
17067 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17068 
      self.ex.write(oprot)
17069 
      oprot.writeFieldEnd()
17070 
    oprot.writeFieldStop()
17071 
    oprot.writeStructEnd()
17072 
 
17073 
  def validate(self):
17074 
    return
17075 
 
17076 
 
17077 
  def __repr__(self):
17078 
    L = ['%s=%r' % (key, value)
17079 
      for key, value in self.__dict__.iteritems()]
17080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17081 
 
17082 
  def __eq__(self, other):
17083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17084 
 
17085 
  def __ne__(self, other):
17086 
    return not (self == other)
3956 chandransh 17087 
 
17088 
class reconcileCodCollection_args:
17089 
  """
17090 
  Attributes:
17091 
   - collectedAmountMap
17092 
   - xferBy
17093 
   - xferTxnId
17094 
   - xferDate
17095 
  """
17096 
 
17097 
  thrift_spec = (
17098 
    None, # 0
17099 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
17100 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
17101 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
17102 
    (4, TType.I64, 'xferDate', None, None, ), # 4
17103 
  )
17104 
 
17105 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
17106 
    self.collectedAmountMap = collectedAmountMap
17107 
    self.xferBy = xferBy
17108 
    self.xferTxnId = xferTxnId
17109 
    self.xferDate = xferDate
17110 
 
17111 
  def read(self, iprot):
17112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17114 
      return
17115 
    iprot.readStructBegin()
17116 
    while True:
17117 
      (fname, ftype, fid) = iprot.readFieldBegin()
17118 
      if ftype == TType.STOP:
17119 
        break
17120 
      if fid == 1:
17121 
        if ftype == TType.MAP:
17122 
          self.collectedAmountMap = {}
5031 varun.gupt 17123 
          (_ktype362, _vtype363, _size361 ) = iprot.readMapBegin()
17124 
          for _i365 in xrange(_size361):
17125 
            _key366 = iprot.readString();
17126 
            _val367 = iprot.readDouble();
17127 
            self.collectedAmountMap[_key366] = _val367
3956 chandransh 17128 
          iprot.readMapEnd()
17129 
        else:
17130 
          iprot.skip(ftype)
17131 
      elif fid == 2:
17132 
        if ftype == TType.STRING:
17133 
          self.xferBy = iprot.readString();
17134 
        else:
17135 
          iprot.skip(ftype)
17136 
      elif fid == 3:
17137 
        if ftype == TType.STRING:
17138 
          self.xferTxnId = iprot.readString();
17139 
        else:
17140 
          iprot.skip(ftype)
17141 
      elif fid == 4:
17142 
        if ftype == TType.I64:
17143 
          self.xferDate = iprot.readI64();
17144 
        else:
17145 
          iprot.skip(ftype)
17146 
      else:
17147 
        iprot.skip(ftype)
17148 
      iprot.readFieldEnd()
17149 
    iprot.readStructEnd()
17150 
 
17151 
  def write(self, oprot):
17152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17154 
      return
17155 
    oprot.writeStructBegin('reconcileCodCollection_args')
17156 
    if self.collectedAmountMap is not None:
17157 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
17158 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
5031 varun.gupt 17159 
      for kiter368,viter369 in self.collectedAmountMap.items():
17160 
        oprot.writeString(kiter368)
17161 
        oprot.writeDouble(viter369)
3956 chandransh 17162 
      oprot.writeMapEnd()
17163 
      oprot.writeFieldEnd()
17164 
    if self.xferBy is not None:
17165 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
17166 
      oprot.writeString(self.xferBy)
17167 
      oprot.writeFieldEnd()
17168 
    if self.xferTxnId is not None:
17169 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
17170 
      oprot.writeString(self.xferTxnId)
17171 
      oprot.writeFieldEnd()
17172 
    if self.xferDate is not None:
17173 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
17174 
      oprot.writeI64(self.xferDate)
17175 
      oprot.writeFieldEnd()
17176 
    oprot.writeFieldStop()
17177 
    oprot.writeStructEnd()
17178 
 
17179 
  def validate(self):
17180 
    return
17181 
 
17182 
 
17183 
  def __repr__(self):
17184 
    L = ['%s=%r' % (key, value)
17185 
      for key, value in self.__dict__.iteritems()]
17186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17187 
 
17188 
  def __eq__(self, other):
17189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17190 
 
17191 
  def __ne__(self, other):
17192 
    return not (self == other)
17193 
 
17194 
class reconcileCodCollection_result:
17195 
  """
17196 
  Attributes:
17197 
   - success
17198 
   - ex
17199 
  """
17200 
 
17201 
  thrift_spec = (
17202 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
17203 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17204 
  )
17205 
 
17206 
  def __init__(self, success=None, ex=None,):
17207 
    self.success = success
17208 
    self.ex = ex
17209 
 
17210 
  def read(self, iprot):
17211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17213 
      return
17214 
    iprot.readStructBegin()
17215 
    while True:
17216 
      (fname, ftype, fid) = iprot.readFieldBegin()
17217 
      if ftype == TType.STOP:
17218 
        break
17219 
      if fid == 0:
17220 
        if ftype == TType.MAP:
17221 
          self.success = {}
5031 varun.gupt 17222 
          (_ktype371, _vtype372, _size370 ) = iprot.readMapBegin()
17223 
          for _i374 in xrange(_size370):
17224 
            _key375 = iprot.readString();
17225 
            _val376 = iprot.readString();
17226 
            self.success[_key375] = _val376
3956 chandransh 17227 
          iprot.readMapEnd()
17228 
        else:
17229 
          iprot.skip(ftype)
17230 
      elif fid == 1:
17231 
        if ftype == TType.STRUCT:
17232 
          self.ex = TransactionServiceException()
17233 
          self.ex.read(iprot)
17234 
        else:
17235 
          iprot.skip(ftype)
17236 
      else:
17237 
        iprot.skip(ftype)
17238 
      iprot.readFieldEnd()
17239 
    iprot.readStructEnd()
17240 
 
17241 
  def write(self, oprot):
17242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17244 
      return
17245 
    oprot.writeStructBegin('reconcileCodCollection_result')
17246 
    if self.success is not None:
17247 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17248 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
5031 varun.gupt 17249 
      for kiter377,viter378 in self.success.items():
17250 
        oprot.writeString(kiter377)
17251 
        oprot.writeString(viter378)
3956 chandransh 17252 
      oprot.writeMapEnd()
17253 
      oprot.writeFieldEnd()
17254 
    if self.ex is not None:
17255 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17256 
      self.ex.write(oprot)
17257 
      oprot.writeFieldEnd()
17258 
    oprot.writeFieldStop()
17259 
    oprot.writeStructEnd()
17260 
 
17261 
  def validate(self):
17262 
    return
17263 
 
17264 
 
17265 
  def __repr__(self):
17266 
    L = ['%s=%r' % (key, value)
17267 
      for key, value in self.__dict__.iteritems()]
17268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17269 
 
17270 
  def __eq__(self, other):
17271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17272 
 
17273 
  def __ne__(self, other):
17274 
    return not (self == other)
4008 mandeep.dh 17275 
 
17276 
class getTransactionsRequiringExtraProcessing_args:
17277 
  """
17278 
  Attributes:
17279 
   - category
17280 
  """
17281 
 
17282 
  thrift_spec = (
17283 
    None, # 0
17284 
    (1, TType.I32, 'category', None, None, ), # 1
17285 
  )
17286 
 
17287 
  def __init__(self, category=None,):
17288 
    self.category = category
17289 
 
17290 
  def read(self, iprot):
17291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17293 
      return
17294 
    iprot.readStructBegin()
17295 
    while True:
17296 
      (fname, ftype, fid) = iprot.readFieldBegin()
17297 
      if ftype == TType.STOP:
17298 
        break
17299 
      if fid == 1:
17300 
        if ftype == TType.I32:
17301 
          self.category = iprot.readI32();
17302 
        else:
17303 
          iprot.skip(ftype)
17304 
      else:
17305 
        iprot.skip(ftype)
17306 
      iprot.readFieldEnd()
17307 
    iprot.readStructEnd()
17308 
 
17309 
  def write(self, oprot):
17310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17312 
      return
17313 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
17314 
    if self.category is not None:
17315 
      oprot.writeFieldBegin('category', TType.I32, 1)
17316 
      oprot.writeI32(self.category)
17317 
      oprot.writeFieldEnd()
17318 
    oprot.writeFieldStop()
17319 
    oprot.writeStructEnd()
17320 
 
17321 
  def validate(self):
17322 
    return
17323 
 
17324 
 
17325 
  def __repr__(self):
17326 
    L = ['%s=%r' % (key, value)
17327 
      for key, value in self.__dict__.iteritems()]
17328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17329 
 
17330 
  def __eq__(self, other):
17331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17332 
 
17333 
  def __ne__(self, other):
17334 
    return not (self == other)
17335 
 
17336 
class getTransactionsRequiringExtraProcessing_result:
17337 
  """
17338 
  Attributes:
17339 
   - success
17340 
  """
17341 
 
17342 
  thrift_spec = (
17343 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
17344 
  )
17345 
 
17346 
  def __init__(self, success=None,):
17347 
    self.success = success
17348 
 
17349 
  def read(self, iprot):
17350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17352 
      return
17353 
    iprot.readStructBegin()
17354 
    while True:
17355 
      (fname, ftype, fid) = iprot.readFieldBegin()
17356 
      if ftype == TType.STOP:
17357 
        break
17358 
      if fid == 0:
17359 
        if ftype == TType.LIST:
17360 
          self.success = []
5031 varun.gupt 17361 
          (_etype382, _size379) = iprot.readListBegin()
17362 
          for _i383 in xrange(_size379):
17363 
            _elem384 = iprot.readI64();
17364 
            self.success.append(_elem384)
4008 mandeep.dh 17365 
          iprot.readListEnd()
17366 
        else:
17367 
          iprot.skip(ftype)
17368 
      else:
17369 
        iprot.skip(ftype)
17370 
      iprot.readFieldEnd()
17371 
    iprot.readStructEnd()
17372 
 
17373 
  def write(self, oprot):
17374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17376 
      return
17377 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
17378 
    if self.success is not None:
17379 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17380 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 17381 
      for iter385 in self.success:
17382 
        oprot.writeI64(iter385)
4008 mandeep.dh 17383 
      oprot.writeListEnd()
17384 
      oprot.writeFieldEnd()
17385 
    oprot.writeFieldStop()
17386 
    oprot.writeStructEnd()
17387 
 
17388 
  def validate(self):
17389 
    return
17390 
 
17391 
 
17392 
  def __repr__(self):
17393 
    L = ['%s=%r' % (key, value)
17394 
      for key, value in self.__dict__.iteritems()]
17395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17396 
 
17397 
  def __eq__(self, other):
17398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17399 
 
17400 
  def __ne__(self, other):
17401 
    return not (self == other)
17402 
 
17403 
class markTransactionAsProcessed_args:
17404 
  """
17405 
  Attributes:
17406 
   - transactionId
17407 
   - category
17408 
  """
17409 
 
17410 
  thrift_spec = (
17411 
    None, # 0
17412 
    (1, TType.I64, 'transactionId', None, None, ), # 1
17413 
    (2, TType.I32, 'category', None, None, ), # 2
17414 
  )
17415 
 
17416 
  def __init__(self, transactionId=None, category=None,):
17417 
    self.transactionId = transactionId
17418 
    self.category = category
17419 
 
17420 
  def read(self, iprot):
17421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17423 
      return
17424 
    iprot.readStructBegin()
17425 
    while True:
17426 
      (fname, ftype, fid) = iprot.readFieldBegin()
17427 
      if ftype == TType.STOP:
17428 
        break
17429 
      if fid == 1:
17430 
        if ftype == TType.I64:
17431 
          self.transactionId = iprot.readI64();
17432 
        else:
17433 
          iprot.skip(ftype)
17434 
      elif fid == 2:
17435 
        if ftype == TType.I32:
17436 
          self.category = iprot.readI32();
17437 
        else:
17438 
          iprot.skip(ftype)
17439 
      else:
17440 
        iprot.skip(ftype)
17441 
      iprot.readFieldEnd()
17442 
    iprot.readStructEnd()
17443 
 
17444 
  def write(self, oprot):
17445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17447 
      return
17448 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
17449 
    if self.transactionId is not None:
17450 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
17451 
      oprot.writeI64(self.transactionId)
17452 
      oprot.writeFieldEnd()
17453 
    if self.category is not None:
17454 
      oprot.writeFieldBegin('category', TType.I32, 2)
17455 
      oprot.writeI32(self.category)
17456 
      oprot.writeFieldEnd()
17457 
    oprot.writeFieldStop()
17458 
    oprot.writeStructEnd()
17459 
 
17460 
  def validate(self):
17461 
    return
17462 
 
17463 
 
17464 
  def __repr__(self):
17465 
    L = ['%s=%r' % (key, value)
17466 
      for key, value in self.__dict__.iteritems()]
17467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17468 
 
17469 
  def __eq__(self, other):
17470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17471 
 
17472 
  def __ne__(self, other):
17473 
    return not (self == other)
17474 
 
17475 
class markTransactionAsProcessed_result:
17476 
 
17477 
  thrift_spec = (
17478 
  )
17479 
 
17480 
  def read(self, iprot):
17481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17483 
      return
17484 
    iprot.readStructBegin()
17485 
    while True:
17486 
      (fname, ftype, fid) = iprot.readFieldBegin()
17487 
      if ftype == TType.STOP:
17488 
        break
17489 
      else:
17490 
        iprot.skip(ftype)
17491 
      iprot.readFieldEnd()
17492 
    iprot.readStructEnd()
17493 
 
17494 
  def write(self, oprot):
17495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17497 
      return
17498 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
17499 
    oprot.writeFieldStop()
17500 
    oprot.writeStructEnd()
17501 
 
17502 
  def validate(self):
17503 
    return
17504 
 
17505 
 
17506 
  def __repr__(self):
17507 
    L = ['%s=%r' % (key, value)
17508 
      for key, value in self.__dict__.iteritems()]
17509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17510 
 
17511 
  def __eq__(self, other):
17512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17513 
 
17514 
  def __ne__(self, other):
17515 
    return not (self == other)
4018 chandransh 17516 
 
17517 
class getItemWiseRiskyOrdersCount_args:
17518 
 
17519 
  thrift_spec = (
17520 
  )
17521 
 
17522 
  def read(self, iprot):
17523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17525 
      return
17526 
    iprot.readStructBegin()
17527 
    while True:
17528 
      (fname, ftype, fid) = iprot.readFieldBegin()
17529 
      if ftype == TType.STOP:
17530 
        break
17531 
      else:
17532 
        iprot.skip(ftype)
17533 
      iprot.readFieldEnd()
17534 
    iprot.readStructEnd()
17535 
 
17536 
  def write(self, oprot):
17537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17539 
      return
17540 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
17541 
    oprot.writeFieldStop()
17542 
    oprot.writeStructEnd()
17543 
 
17544 
  def validate(self):
17545 
    return
17546 
 
17547 
 
17548 
  def __repr__(self):
17549 
    L = ['%s=%r' % (key, value)
17550 
      for key, value in self.__dict__.iteritems()]
17551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17552 
 
17553 
  def __eq__(self, other):
17554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17555 
 
17556 
  def __ne__(self, other):
17557 
    return not (self == other)
17558 
 
17559 
class getItemWiseRiskyOrdersCount_result:
17560 
  """
17561 
  Attributes:
17562 
   - success
17563 
  """
17564 
 
17565 
  thrift_spec = (
17566 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
17567 
  )
17568 
 
17569 
  def __init__(self, success=None,):
17570 
    self.success = success
17571 
 
17572 
  def read(self, iprot):
17573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17575 
      return
17576 
    iprot.readStructBegin()
17577 
    while True:
17578 
      (fname, ftype, fid) = iprot.readFieldBegin()
17579 
      if ftype == TType.STOP:
17580 
        break
17581 
      if fid == 0:
17582 
        if ftype == TType.MAP:
17583 
          self.success = {}
5031 varun.gupt 17584 
          (_ktype387, _vtype388, _size386 ) = iprot.readMapBegin()
17585 
          for _i390 in xrange(_size386):
17586 
            _key391 = iprot.readI64();
17587 
            _val392 = iprot.readI64();
17588 
            self.success[_key391] = _val392
4018 chandransh 17589 
          iprot.readMapEnd()
17590 
        else:
17591 
          iprot.skip(ftype)
17592 
      else:
17593 
        iprot.skip(ftype)
17594 
      iprot.readFieldEnd()
17595 
    iprot.readStructEnd()
17596 
 
17597 
  def write(self, oprot):
17598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17600 
      return
17601 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
17602 
    if self.success is not None:
17603 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17604 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5031 varun.gupt 17605 
      for kiter393,viter394 in self.success.items():
17606 
        oprot.writeI64(kiter393)
17607 
        oprot.writeI64(viter394)
4018 chandransh 17608 
      oprot.writeMapEnd()
17609 
      oprot.writeFieldEnd()
17610 
    oprot.writeFieldStop()
17611 
    oprot.writeStructEnd()
17612 
 
17613 
  def validate(self):
17614 
    return
17615 
 
17616 
 
17617 
  def __repr__(self):
17618 
    L = ['%s=%r' % (key, value)
17619 
      for key, value in self.__dict__.iteritems()]
17620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17621 
 
17622 
  def __eq__(self, other):
17623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17624 
 
17625 
  def __ne__(self, other):
17626 
    return not (self == other)
4247 rajveer 17627 
 
4295 varun.gupt 17628 
class getOrdersForItemIds_args:
17629 
  """
17630 
  Attributes:
17631 
   - itemIds
17632 
  """
17633 
 
17634 
  thrift_spec = (
17635 
    None, # 0
17636 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
17637 
  )
17638 
 
17639 
  def __init__(self, itemIds=None,):
17640 
    self.itemIds = itemIds
17641 
 
17642 
  def read(self, iprot):
17643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17645 
      return
17646 
    iprot.readStructBegin()
17647 
    while True:
17648 
      (fname, ftype, fid) = iprot.readFieldBegin()
17649 
      if ftype == TType.STOP:
17650 
        break
17651 
      if fid == 1:
17652 
        if ftype == TType.LIST:
17653 
          self.itemIds = []
5031 varun.gupt 17654 
          (_etype398, _size395) = iprot.readListBegin()
17655 
          for _i399 in xrange(_size395):
17656 
            _elem400 = iprot.readI64();
17657 
            self.itemIds.append(_elem400)
4295 varun.gupt 17658 
          iprot.readListEnd()
17659 
        else:
17660 
          iprot.skip(ftype)
17661 
      else:
17662 
        iprot.skip(ftype)
17663 
      iprot.readFieldEnd()
17664 
    iprot.readStructEnd()
17665 
 
17666 
  def write(self, oprot):
17667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17669 
      return
17670 
    oprot.writeStructBegin('getOrdersForItemIds_args')
17671 
    if self.itemIds is not None:
17672 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
17673 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5031 varun.gupt 17674 
      for iter401 in self.itemIds:
17675 
        oprot.writeI64(iter401)
4295 varun.gupt 17676 
      oprot.writeListEnd()
17677 
      oprot.writeFieldEnd()
17678 
    oprot.writeFieldStop()
17679 
    oprot.writeStructEnd()
17680 
 
17681 
  def validate(self):
17682 
    return
17683 
 
17684 
 
17685 
  def __repr__(self):
17686 
    L = ['%s=%r' % (key, value)
17687 
      for key, value in self.__dict__.iteritems()]
17688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17689 
 
17690 
  def __eq__(self, other):
17691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17692 
 
17693 
  def __ne__(self, other):
17694 
    return not (self == other)
17695 
 
17696 
class getOrdersForItemIds_result:
17697 
  """
17698 
  Attributes:
17699 
   - success
17700 
  """
17701 
 
17702 
  thrift_spec = (
17703 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17704 
  )
17705 
 
17706 
  def __init__(self, success=None,):
17707 
    self.success = success
17708 
 
17709 
  def read(self, iprot):
17710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17712 
      return
17713 
    iprot.readStructBegin()
17714 
    while True:
17715 
      (fname, ftype, fid) = iprot.readFieldBegin()
17716 
      if ftype == TType.STOP:
17717 
        break
17718 
      if fid == 0:
17719 
        if ftype == TType.LIST:
17720 
          self.success = []
5031 varun.gupt 17721 
          (_etype405, _size402) = iprot.readListBegin()
17722 
          for _i406 in xrange(_size402):
17723 
            _elem407 = Order()
17724 
            _elem407.read(iprot)
17725 
            self.success.append(_elem407)
4295 varun.gupt 17726 
          iprot.readListEnd()
17727 
        else:
17728 
          iprot.skip(ftype)
17729 
      else:
17730 
        iprot.skip(ftype)
17731 
      iprot.readFieldEnd()
17732 
    iprot.readStructEnd()
17733 
 
17734 
  def write(self, oprot):
17735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17737 
      return
17738 
    oprot.writeStructBegin('getOrdersForItemIds_result')
17739 
    if self.success is not None:
17740 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17741 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 17742 
      for iter408 in self.success:
17743 
        iter408.write(oprot)
4295 varun.gupt 17744 
      oprot.writeListEnd()
17745 
      oprot.writeFieldEnd()
17746 
    oprot.writeFieldStop()
17747 
    oprot.writeStructEnd()
17748 
 
17749 
  def validate(self):
17750 
    return
17751 
 
17752 
 
17753 
  def __repr__(self):
17754 
    L = ['%s=%r' % (key, value)
17755 
      for key, value in self.__dict__.iteritems()]
17756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17757 
 
17758 
  def __eq__(self, other):
17759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17760 
 
17761 
  def __ne__(self, other):
17762 
    return not (self == other)
17763 
 
4247 rajveer 17764 
class markOrderCancellationRequestReceived_args:
17765 
  """
17766 
  Attributes:
17767 
   - orderId
17768 
  """
17769 
 
17770 
  thrift_spec = (
17771 
    None, # 0
17772 
    (1, TType.I64, 'orderId', None, None, ), # 1
17773 
  )
17774 
 
17775 
  def __init__(self, orderId=None,):
17776 
    self.orderId = orderId
17777 
 
17778 
  def read(self, iprot):
17779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17781 
      return
17782 
    iprot.readStructBegin()
17783 
    while True:
17784 
      (fname, ftype, fid) = iprot.readFieldBegin()
17785 
      if ftype == TType.STOP:
17786 
        break
17787 
      if fid == 1:
17788 
        if ftype == TType.I64:
17789 
          self.orderId = iprot.readI64();
17790 
        else:
17791 
          iprot.skip(ftype)
17792 
      else:
17793 
        iprot.skip(ftype)
17794 
      iprot.readFieldEnd()
17795 
    iprot.readStructEnd()
17796 
 
17797 
  def write(self, oprot):
17798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17800 
      return
17801 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
17802 
    if self.orderId is not None:
17803 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17804 
      oprot.writeI64(self.orderId)
17805 
      oprot.writeFieldEnd()
17806 
    oprot.writeFieldStop()
17807 
    oprot.writeStructEnd()
17808 
 
17809 
  def validate(self):
17810 
    return
17811 
 
17812 
 
17813 
  def __repr__(self):
17814 
    L = ['%s=%r' % (key, value)
17815 
      for key, value in self.__dict__.iteritems()]
17816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17817 
 
17818 
  def __eq__(self, other):
17819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17820 
 
17821 
  def __ne__(self, other):
17822 
    return not (self == other)
17823 
 
17824 
class markOrderCancellationRequestReceived_result:
17825 
  """
17826 
  Attributes:
17827 
   - ex
17828 
  """
17829 
 
17830 
  thrift_spec = (
17831 
    None, # 0
17832 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17833 
  )
17834 
 
17835 
  def __init__(self, ex=None,):
17836 
    self.ex = ex
17837 
 
17838 
  def read(self, iprot):
17839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17841 
      return
17842 
    iprot.readStructBegin()
17843 
    while True:
17844 
      (fname, ftype, fid) = iprot.readFieldBegin()
17845 
      if ftype == TType.STOP:
17846 
        break
17847 
      if fid == 1:
17848 
        if ftype == TType.STRUCT:
17849 
          self.ex = TransactionServiceException()
17850 
          self.ex.read(iprot)
17851 
        else:
17852 
          iprot.skip(ftype)
17853 
      else:
17854 
        iprot.skip(ftype)
17855 
      iprot.readFieldEnd()
17856 
    iprot.readStructEnd()
17857 
 
17858 
  def write(self, oprot):
17859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17861 
      return
17862 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
17863 
    if self.ex is not None:
17864 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17865 
      self.ex.write(oprot)
17866 
      oprot.writeFieldEnd()
17867 
    oprot.writeFieldStop()
17868 
    oprot.writeStructEnd()
17869 
 
17870 
  def validate(self):
17871 
    return
17872 
 
17873 
 
17874 
  def __repr__(self):
17875 
    L = ['%s=%r' % (key, value)
17876 
      for key, value in self.__dict__.iteritems()]
17877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17878 
 
17879 
  def __eq__(self, other):
17880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17881 
 
17882 
  def __ne__(self, other):
17883 
    return not (self == other)
17884 
 
17885 
class markOrderCancellationRequestConfirmed_args:
17886 
  """
17887 
  Attributes:
17888 
   - orderId
17889 
  """
17890 
 
17891 
  thrift_spec = (
17892 
    None, # 0
17893 
    (1, TType.I64, 'orderId', None, None, ), # 1
17894 
  )
17895 
 
17896 
  def __init__(self, orderId=None,):
17897 
    self.orderId = orderId
17898 
 
17899 
  def read(self, iprot):
17900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17902 
      return
17903 
    iprot.readStructBegin()
17904 
    while True:
17905 
      (fname, ftype, fid) = iprot.readFieldBegin()
17906 
      if ftype == TType.STOP:
17907 
        break
17908 
      if fid == 1:
17909 
        if ftype == TType.I64:
17910 
          self.orderId = iprot.readI64();
17911 
        else:
17912 
          iprot.skip(ftype)
17913 
      else:
17914 
        iprot.skip(ftype)
17915 
      iprot.readFieldEnd()
17916 
    iprot.readStructEnd()
17917 
 
17918 
  def write(self, oprot):
17919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17921 
      return
17922 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
17923 
    if self.orderId is not None:
17924 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17925 
      oprot.writeI64(self.orderId)
17926 
      oprot.writeFieldEnd()
17927 
    oprot.writeFieldStop()
17928 
    oprot.writeStructEnd()
17929 
 
17930 
  def validate(self):
17931 
    return
17932 
 
17933 
 
17934 
  def __repr__(self):
17935 
    L = ['%s=%r' % (key, value)
17936 
      for key, value in self.__dict__.iteritems()]
17937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17938 
 
17939 
  def __eq__(self, other):
17940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17941 
 
17942 
  def __ne__(self, other):
17943 
    return not (self == other)
17944 
 
17945 
class markOrderCancellationRequestConfirmed_result:
17946 
  """
17947 
  Attributes:
17948 
   - ex
17949 
  """
17950 
 
17951 
  thrift_spec = (
17952 
    None, # 0
17953 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17954 
  )
17955 
 
17956 
  def __init__(self, ex=None,):
17957 
    self.ex = ex
17958 
 
17959 
  def read(self, iprot):
17960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17962 
      return
17963 
    iprot.readStructBegin()
17964 
    while True:
17965 
      (fname, ftype, fid) = iprot.readFieldBegin()
17966 
      if ftype == TType.STOP:
17967 
        break
17968 
      if fid == 1:
17969 
        if ftype == TType.STRUCT:
17970 
          self.ex = TransactionServiceException()
17971 
          self.ex.read(iprot)
17972 
        else:
17973 
          iprot.skip(ftype)
17974 
      else:
17975 
        iprot.skip(ftype)
17976 
      iprot.readFieldEnd()
17977 
    iprot.readStructEnd()
17978 
 
17979 
  def write(self, oprot):
17980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17982 
      return
17983 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
17984 
    if self.ex is not None:
17985 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17986 
      self.ex.write(oprot)
17987 
      oprot.writeFieldEnd()
17988 
    oprot.writeFieldStop()
17989 
    oprot.writeStructEnd()
17990 
 
17991 
  def validate(self):
17992 
    return
17993 
 
17994 
 
17995 
  def __repr__(self):
17996 
    L = ['%s=%r' % (key, value)
17997 
      for key, value in self.__dict__.iteritems()]
17998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17999 
 
18000 
  def __eq__(self, other):
18001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18002 
 
18003 
  def __ne__(self, other):
18004 
    return not (self == other)
18005 
 
18006 
class markOrderCancellationRequestDenied_args:
18007 
  """
18008 
  Attributes:
18009 
   - orderId
18010 
  """
18011 
 
18012 
  thrift_spec = (
18013 
    None, # 0
18014 
    (1, TType.I64, 'orderId', None, None, ), # 1
18015 
  )
18016 
 
18017 
  def __init__(self, orderId=None,):
18018 
    self.orderId = orderId
18019 
 
18020 
  def read(self, iprot):
18021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18023 
      return
18024 
    iprot.readStructBegin()
18025 
    while True:
18026 
      (fname, ftype, fid) = iprot.readFieldBegin()
18027 
      if ftype == TType.STOP:
18028 
        break
18029 
      if fid == 1:
18030 
        if ftype == TType.I64:
18031 
          self.orderId = iprot.readI64();
18032 
        else:
18033 
          iprot.skip(ftype)
18034 
      else:
18035 
        iprot.skip(ftype)
18036 
      iprot.readFieldEnd()
18037 
    iprot.readStructEnd()
18038 
 
18039 
  def write(self, oprot):
18040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18042 
      return
18043 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
18044 
    if self.orderId is not None:
18045 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18046 
      oprot.writeI64(self.orderId)
18047 
      oprot.writeFieldEnd()
18048 
    oprot.writeFieldStop()
18049 
    oprot.writeStructEnd()
18050 
 
18051 
  def validate(self):
18052 
    return
18053 
 
18054 
 
18055 
  def __repr__(self):
18056 
    L = ['%s=%r' % (key, value)
18057 
      for key, value in self.__dict__.iteritems()]
18058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18059 
 
18060 
  def __eq__(self, other):
18061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18062 
 
18063 
  def __ne__(self, other):
18064 
    return not (self == other)
18065 
 
18066 
class markOrderCancellationRequestDenied_result:
18067 
  """
18068 
  Attributes:
18069 
   - ex
18070 
  """
18071 
 
18072 
  thrift_spec = (
18073 
    None, # 0
18074 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18075 
  )
18076 
 
18077 
  def __init__(self, ex=None,):
18078 
    self.ex = ex
18079 
 
18080 
  def read(self, iprot):
18081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18083 
      return
18084 
    iprot.readStructBegin()
18085 
    while True:
18086 
      (fname, ftype, fid) = iprot.readFieldBegin()
18087 
      if ftype == TType.STOP:
18088 
        break
18089 
      if fid == 1:
18090 
        if ftype == TType.STRUCT:
18091 
          self.ex = TransactionServiceException()
18092 
          self.ex.read(iprot)
18093 
        else:
18094 
          iprot.skip(ftype)
18095 
      else:
18096 
        iprot.skip(ftype)
18097 
      iprot.readFieldEnd()
18098 
    iprot.readStructEnd()
18099 
 
18100 
  def write(self, oprot):
18101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18103 
      return
18104 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
18105 
    if self.ex is not None:
18106 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18107 
      self.ex.write(oprot)
18108 
      oprot.writeFieldEnd()
18109 
    oprot.writeFieldStop()
18110 
    oprot.writeStructEnd()
18111 
 
18112 
  def validate(self):
18113 
    return
18114 
 
18115 
 
18116 
  def __repr__(self):
18117 
    L = ['%s=%r' % (key, value)
18118 
      for key, value in self.__dict__.iteritems()]
18119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18120 
 
18121 
  def __eq__(self, other):
18122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18123 
 
18124 
  def __ne__(self, other):
18125 
    return not (self == other)
18126 
 
4258 rajveer 18127 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 18128 
  """
18129 
  Attributes:
4258 rajveer 18130 
   - transactionId
4247 rajveer 18131 
  """
18132 
 
18133 
  thrift_spec = (
18134 
    None, # 0
4258 rajveer 18135 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 18136 
  )
18137 
 
4258 rajveer 18138 
  def __init__(self, transactionId=None,):
18139 
    self.transactionId = transactionId
4247 rajveer 18140 
 
18141 
  def read(self, iprot):
18142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18144 
      return
18145 
    iprot.readStructBegin()
18146 
    while True:
18147 
      (fname, ftype, fid) = iprot.readFieldBegin()
18148 
      if ftype == TType.STOP:
18149 
        break
18150 
      if fid == 1:
18151 
        if ftype == TType.I64:
4258 rajveer 18152 
          self.transactionId = iprot.readI64();
4247 rajveer 18153 
        else:
18154 
          iprot.skip(ftype)
18155 
      else:
18156 
        iprot.skip(ftype)
18157 
      iprot.readFieldEnd()
18158 
    iprot.readStructEnd()
18159 
 
18160 
  def write(self, oprot):
18161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18163 
      return
4258 rajveer 18164 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
18165 
    if self.transactionId is not None:
18166 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18167 
      oprot.writeI64(self.transactionId)
4247 rajveer 18168 
      oprot.writeFieldEnd()
18169 
    oprot.writeFieldStop()
18170 
    oprot.writeStructEnd()
18171 
 
18172 
  def validate(self):
18173 
    return
18174 
 
18175 
 
18176 
  def __repr__(self):
18177 
    L = ['%s=%r' % (key, value)
18178 
      for key, value in self.__dict__.iteritems()]
18179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18180 
 
18181 
  def __eq__(self, other):
18182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18183 
 
18184 
  def __ne__(self, other):
18185 
    return not (self == other)
18186 
 
4258 rajveer 18187 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 18188 
  """
18189 
  Attributes:
18190 
   - ex
18191 
  """
18192 
 
18193 
  thrift_spec = (
18194 
    None, # 0
18195 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18196 
  )
18197 
 
18198 
  def __init__(self, ex=None,):
18199 
    self.ex = ex
18200 
 
18201 
  def read(self, iprot):
18202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18204 
      return
18205 
    iprot.readStructBegin()
18206 
    while True:
18207 
      (fname, ftype, fid) = iprot.readFieldBegin()
18208 
      if ftype == TType.STOP:
18209 
        break
18210 
      if fid == 1:
18211 
        if ftype == TType.STRUCT:
18212 
          self.ex = TransactionServiceException()
18213 
          self.ex.read(iprot)
18214 
        else:
18215 
          iprot.skip(ftype)
18216 
      else:
18217 
        iprot.skip(ftype)
18218 
      iprot.readFieldEnd()
18219 
    iprot.readStructEnd()
18220 
 
18221 
  def write(self, oprot):
18222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18224 
      return
4258 rajveer 18225 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 18226 
    if self.ex is not None:
18227 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18228 
      self.ex.write(oprot)
18229 
      oprot.writeFieldEnd()
18230 
    oprot.writeFieldStop()
18231 
    oprot.writeStructEnd()
18232 
 
18233 
  def validate(self):
18234 
    return
18235 
 
18236 
 
18237 
  def __repr__(self):
18238 
    L = ['%s=%r' % (key, value)
18239 
      for key, value in self.__dict__.iteritems()]
18240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18241 
 
18242 
  def __eq__(self, other):
18243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18244 
 
18245 
  def __ne__(self, other):
18246 
    return not (self == other)
4259 anupam.sin 18247 
 
18248 
class refundTransaction_args:
18249 
  """
18250 
  Attributes:
18251 
   - transactionId
18252 
   - refundedBy
18253 
   - reason
18254 
  """
18255 
 
18256 
  thrift_spec = (
18257 
    None, # 0
18258 
    (1, TType.I64, 'transactionId', None, None, ), # 1
18259 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18260 
    (3, TType.STRING, 'reason', None, None, ), # 3
18261 
  )
18262 
 
18263 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
18264 
    self.transactionId = transactionId
18265 
    self.refundedBy = refundedBy
18266 
    self.reason = reason
18267 
 
18268 
  def read(self, iprot):
18269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18271 
      return
18272 
    iprot.readStructBegin()
18273 
    while True:
18274 
      (fname, ftype, fid) = iprot.readFieldBegin()
18275 
      if ftype == TType.STOP:
18276 
        break
18277 
      if fid == 1:
18278 
        if ftype == TType.I64:
18279 
          self.transactionId = iprot.readI64();
18280 
        else:
18281 
          iprot.skip(ftype)
18282 
      elif fid == 2:
18283 
        if ftype == TType.STRING:
18284 
          self.refundedBy = iprot.readString();
18285 
        else:
18286 
          iprot.skip(ftype)
18287 
      elif fid == 3:
18288 
        if ftype == TType.STRING:
18289 
          self.reason = iprot.readString();
18290 
        else:
18291 
          iprot.skip(ftype)
18292 
      else:
18293 
        iprot.skip(ftype)
18294 
      iprot.readFieldEnd()
18295 
    iprot.readStructEnd()
18296 
 
18297 
  def write(self, oprot):
18298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18300 
      return
18301 
    oprot.writeStructBegin('refundTransaction_args')
18302 
    if self.transactionId is not None:
18303 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18304 
      oprot.writeI64(self.transactionId)
18305 
      oprot.writeFieldEnd()
18306 
    if self.refundedBy is not None:
18307 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18308 
      oprot.writeString(self.refundedBy)
18309 
      oprot.writeFieldEnd()
18310 
    if self.reason is not None:
18311 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18312 
      oprot.writeString(self.reason)
18313 
      oprot.writeFieldEnd()
18314 
    oprot.writeFieldStop()
18315 
    oprot.writeStructEnd()
18316 
 
18317 
  def validate(self):
18318 
    return
18319 
 
18320 
 
18321 
  def __repr__(self):
18322 
    L = ['%s=%r' % (key, value)
18323 
      for key, value in self.__dict__.iteritems()]
18324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18325 
 
18326 
  def __eq__(self, other):
18327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18328 
 
18329 
  def __ne__(self, other):
18330 
    return not (self == other)
18331 
 
18332 
class refundTransaction_result:
18333 
  """
18334 
  Attributes:
18335 
   - ex
18336 
  """
18337 
 
18338 
  thrift_spec = (
18339 
    None, # 0
18340 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18341 
  )
18342 
 
18343 
  def __init__(self, ex=None,):
18344 
    self.ex = ex
18345 
 
18346 
  def read(self, iprot):
18347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18349 
      return
18350 
    iprot.readStructBegin()
18351 
    while True:
18352 
      (fname, ftype, fid) = iprot.readFieldBegin()
18353 
      if ftype == TType.STOP:
18354 
        break
18355 
      if fid == 1:
18356 
        if ftype == TType.STRUCT:
18357 
          self.ex = TransactionServiceException()
18358 
          self.ex.read(iprot)
18359 
        else:
18360 
          iprot.skip(ftype)
18361 
      else:
18362 
        iprot.skip(ftype)
18363 
      iprot.readFieldEnd()
18364 
    iprot.readStructEnd()
18365 
 
18366 
  def write(self, oprot):
18367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18369 
      return
18370 
    oprot.writeStructBegin('refundTransaction_result')
18371 
    if self.ex is not None:
18372 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18373 
      self.ex.write(oprot)
18374 
      oprot.writeFieldEnd()
18375 
    oprot.writeFieldStop()
18376 
    oprot.writeStructEnd()
18377 
 
18378 
  def validate(self):
18379 
    return
18380 
 
18381 
 
18382 
  def __repr__(self):
18383 
    L = ['%s=%r' % (key, value)
18384 
      for key, value in self.__dict__.iteritems()]
18385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18386 
 
18387 
  def __eq__(self, other):
18388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18389 
 
18390 
  def __ne__(self, other):
18391 
    return not (self == other)
4285 rajveer 18392 
 
4324 mandeep.dh 18393 
class updateShipmentAddress_args:
18394 
  """
18395 
  Attributes:
18396 
   - orderId
18397 
   - addressId
18398 
  """
18399 
 
18400 
  thrift_spec = (
18401 
    None, # 0
18402 
    (1, TType.I64, 'orderId', None, None, ), # 1
18403 
    (2, TType.I64, 'addressId', None, None, ), # 2
18404 
  )
18405 
 
18406 
  def __init__(self, orderId=None, addressId=None,):
18407 
    self.orderId = orderId
18408 
    self.addressId = addressId
18409 
 
18410 
  def read(self, iprot):
18411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18413 
      return
18414 
    iprot.readStructBegin()
18415 
    while True:
18416 
      (fname, ftype, fid) = iprot.readFieldBegin()
18417 
      if ftype == TType.STOP:
18418 
        break
18419 
      if fid == 1:
18420 
        if ftype == TType.I64:
18421 
          self.orderId = iprot.readI64();
18422 
        else:
18423 
          iprot.skip(ftype)
18424 
      elif fid == 2:
18425 
        if ftype == TType.I64:
18426 
          self.addressId = iprot.readI64();
18427 
        else:
18428 
          iprot.skip(ftype)
18429 
      else:
18430 
        iprot.skip(ftype)
18431 
      iprot.readFieldEnd()
18432 
    iprot.readStructEnd()
18433 
 
18434 
  def write(self, oprot):
18435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18437 
      return
18438 
    oprot.writeStructBegin('updateShipmentAddress_args')
18439 
    if self.orderId is not None:
18440 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18441 
      oprot.writeI64(self.orderId)
18442 
      oprot.writeFieldEnd()
18443 
    if self.addressId is not None:
18444 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
18445 
      oprot.writeI64(self.addressId)
18446 
      oprot.writeFieldEnd()
18447 
    oprot.writeFieldStop()
18448 
    oprot.writeStructEnd()
18449 
 
18450 
  def validate(self):
18451 
    return
18452 
 
18453 
 
18454 
  def __repr__(self):
18455 
    L = ['%s=%r' % (key, value)
18456 
      for key, value in self.__dict__.iteritems()]
18457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18458 
 
18459 
  def __eq__(self, other):
18460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18461 
 
18462 
  def __ne__(self, other):
18463 
    return not (self == other)
18464 
 
18465 
class updateShipmentAddress_result:
18466 
  """
18467 
  Attributes:
18468 
   - ex
18469 
  """
18470 
 
18471 
  thrift_spec = (
18472 
    None, # 0
18473 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18474 
  )
18475 
 
18476 
  def __init__(self, ex=None,):
18477 
    self.ex = ex
18478 
 
18479 
  def read(self, iprot):
18480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18482 
      return
18483 
    iprot.readStructBegin()
18484 
    while True:
18485 
      (fname, ftype, fid) = iprot.readFieldBegin()
18486 
      if ftype == TType.STOP:
18487 
        break
18488 
      if fid == 1:
18489 
        if ftype == TType.STRUCT:
18490 
          self.ex = TransactionServiceException()
18491 
          self.ex.read(iprot)
18492 
        else:
18493 
          iprot.skip(ftype)
18494 
      else:
18495 
        iprot.skip(ftype)
18496 
      iprot.readFieldEnd()
18497 
    iprot.readStructEnd()
18498 
 
18499 
  def write(self, oprot):
18500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18502 
      return
18503 
    oprot.writeStructBegin('updateShipmentAddress_result')
18504 
    if self.ex is not None:
18505 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18506 
      self.ex.write(oprot)
18507 
      oprot.writeFieldEnd()
18508 
    oprot.writeFieldStop()
18509 
    oprot.writeStructEnd()
18510 
 
18511 
  def validate(self):
18512 
    return
18513 
 
18514 
 
18515 
  def __repr__(self):
18516 
    L = ['%s=%r' % (key, value)
18517 
      for key, value in self.__dict__.iteritems()]
18518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18519 
 
18520 
  def __eq__(self, other):
18521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18522 
 
18523 
  def __ne__(self, other):
18524 
    return not (self == other)
18525 
 
4285 rajveer 18526 
class acceptOrdersForItemId_args:
18527 
  """
18528 
  Attributes:
18529 
   - itemId
18530 
   - inventory
18531 
  """
18532 
 
18533 
  thrift_spec = (
18534 
    None, # 0
18535 
    (1, TType.I64, 'itemId', None, None, ), # 1
18536 
    (2, TType.I64, 'inventory', None, None, ), # 2
18537 
  )
18538 
 
18539 
  def __init__(self, itemId=None, inventory=None,):
18540 
    self.itemId = itemId
18541 
    self.inventory = inventory
18542 
 
18543 
  def read(self, iprot):
18544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18546 
      return
18547 
    iprot.readStructBegin()
18548 
    while True:
18549 
      (fname, ftype, fid) = iprot.readFieldBegin()
18550 
      if ftype == TType.STOP:
18551 
        break
18552 
      if fid == 1:
18553 
        if ftype == TType.I64:
18554 
          self.itemId = iprot.readI64();
18555 
        else:
18556 
          iprot.skip(ftype)
18557 
      elif fid == 2:
18558 
        if ftype == TType.I64:
18559 
          self.inventory = iprot.readI64();
18560 
        else:
18561 
          iprot.skip(ftype)
18562 
      else:
18563 
        iprot.skip(ftype)
18564 
      iprot.readFieldEnd()
18565 
    iprot.readStructEnd()
18566 
 
18567 
  def write(self, oprot):
18568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18570 
      return
18571 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
18572 
    if self.itemId is not None:
18573 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18574 
      oprot.writeI64(self.itemId)
18575 
      oprot.writeFieldEnd()
18576 
    if self.inventory is not None:
18577 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
18578 
      oprot.writeI64(self.inventory)
18579 
      oprot.writeFieldEnd()
18580 
    oprot.writeFieldStop()
18581 
    oprot.writeStructEnd()
18582 
 
18583 
  def validate(self):
18584 
    return
18585 
 
18586 
 
18587 
  def __repr__(self):
18588 
    L = ['%s=%r' % (key, value)
18589 
      for key, value in self.__dict__.iteritems()]
18590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18591 
 
18592 
  def __eq__(self, other):
18593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18594 
 
18595 
  def __ne__(self, other):
18596 
    return not (self == other)
18597 
 
18598 
class acceptOrdersForItemId_result:
18599 
  """
18600 
  Attributes:
18601 
   - success
18602 
   - ex
18603 
  """
18604 
 
18605 
  thrift_spec = (
18606 
    (0, TType.BOOL, 'success', None, None, ), # 0
18607 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18608 
  )
18609 
 
18610 
  def __init__(self, success=None, ex=None,):
18611 
    self.success = success
18612 
    self.ex = ex
18613 
 
18614 
  def read(self, iprot):
18615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18617 
      return
18618 
    iprot.readStructBegin()
18619 
    while True:
18620 
      (fname, ftype, fid) = iprot.readFieldBegin()
18621 
      if ftype == TType.STOP:
18622 
        break
18623 
      if fid == 0:
18624 
        if ftype == TType.BOOL:
18625 
          self.success = iprot.readBool();
18626 
        else:
18627 
          iprot.skip(ftype)
18628 
      elif fid == 1:
18629 
        if ftype == TType.STRUCT:
18630 
          self.ex = TransactionServiceException()
18631 
          self.ex.read(iprot)
18632 
        else:
18633 
          iprot.skip(ftype)
18634 
      else:
18635 
        iprot.skip(ftype)
18636 
      iprot.readFieldEnd()
18637 
    iprot.readStructEnd()
18638 
 
18639 
  def write(self, oprot):
18640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18642 
      return
18643 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
18644 
    if self.success is not None:
18645 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18646 
      oprot.writeBool(self.success)
18647 
      oprot.writeFieldEnd()
18648 
    if self.ex is not None:
18649 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18650 
      self.ex.write(oprot)
18651 
      oprot.writeFieldEnd()
18652 
    oprot.writeFieldStop()
18653 
    oprot.writeStructEnd()
18654 
 
18655 
  def validate(self):
18656 
    return
18657 
 
18658 
 
18659 
  def __repr__(self):
18660 
    L = ['%s=%r' % (key, value)
18661 
      for key, value in self.__dict__.iteritems()]
18662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18663 
 
18664 
  def __eq__(self, other):
18665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18666 
 
18667 
  def __ne__(self, other):
18668 
    return not (self == other)
4303 rajveer 18669 
 
18670 
class markOrdersAsPORaised_args:
18671 
  """
18672 
  Attributes:
18673 
   - vendorId
18674 
   - itemId
18675 
   - quantity
18676 
   - estimate
4369 rajveer 18677 
   - isReminder
4303 rajveer 18678 
  """
18679 
 
18680 
  thrift_spec = (
18681 
    None, # 0
18682 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18683 
    (2, TType.I64, 'itemId', None, None, ), # 2
18684 
    (3, TType.I64, 'quantity', None, None, ), # 3
18685 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18686 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18687 
  )
18688 
 
4369 rajveer 18689 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18690 
    self.vendorId = vendorId
18691 
    self.itemId = itemId
18692 
    self.quantity = quantity
18693 
    self.estimate = estimate
4369 rajveer 18694 
    self.isReminder = isReminder
4303 rajveer 18695 
 
18696 
  def read(self, iprot):
18697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18699 
      return
18700 
    iprot.readStructBegin()
18701 
    while True:
18702 
      (fname, ftype, fid) = iprot.readFieldBegin()
18703 
      if ftype == TType.STOP:
18704 
        break
18705 
      if fid == 1:
18706 
        if ftype == TType.I64:
18707 
          self.vendorId = iprot.readI64();
18708 
        else:
18709 
          iprot.skip(ftype)
18710 
      elif fid == 2:
18711 
        if ftype == TType.I64:
18712 
          self.itemId = iprot.readI64();
18713 
        else:
18714 
          iprot.skip(ftype)
18715 
      elif fid == 3:
18716 
        if ftype == TType.I64:
18717 
          self.quantity = iprot.readI64();
18718 
        else:
18719 
          iprot.skip(ftype)
18720 
      elif fid == 4:
18721 
        if ftype == TType.I64:
18722 
          self.estimate = iprot.readI64();
18723 
        else:
18724 
          iprot.skip(ftype)
4369 rajveer 18725 
      elif fid == 5:
18726 
        if ftype == TType.BOOL:
18727 
          self.isReminder = iprot.readBool();
18728 
        else:
18729 
          iprot.skip(ftype)
4303 rajveer 18730 
      else:
18731 
        iprot.skip(ftype)
18732 
      iprot.readFieldEnd()
18733 
    iprot.readStructEnd()
18734 
 
18735 
  def write(self, oprot):
18736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18738 
      return
18739 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
18740 
    if self.vendorId is not None:
18741 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18742 
      oprot.writeI64(self.vendorId)
18743 
      oprot.writeFieldEnd()
18744 
    if self.itemId is not None:
18745 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18746 
      oprot.writeI64(self.itemId)
18747 
      oprot.writeFieldEnd()
18748 
    if self.quantity is not None:
18749 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18750 
      oprot.writeI64(self.quantity)
18751 
      oprot.writeFieldEnd()
18752 
    if self.estimate is not None:
18753 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18754 
      oprot.writeI64(self.estimate)
18755 
      oprot.writeFieldEnd()
4369 rajveer 18756 
    if self.isReminder is not None:
18757 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18758 
      oprot.writeBool(self.isReminder)
18759 
      oprot.writeFieldEnd()
4303 rajveer 18760 
    oprot.writeFieldStop()
18761 
    oprot.writeStructEnd()
18762 
 
18763 
  def validate(self):
18764 
    return
18765 
 
18766 
 
18767 
  def __repr__(self):
18768 
    L = ['%s=%r' % (key, value)
18769 
      for key, value in self.__dict__.iteritems()]
18770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18771 
 
18772 
  def __eq__(self, other):
18773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18774 
 
18775 
  def __ne__(self, other):
18776 
    return not (self == other)
18777 
 
18778 
class markOrdersAsPORaised_result:
18779 
  """
18780 
  Attributes:
18781 
   - ex
18782 
  """
18783 
 
18784 
  thrift_spec = (
18785 
    None, # 0
18786 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18787 
  )
18788 
 
18789 
  def __init__(self, ex=None,):
18790 
    self.ex = ex
18791 
 
18792 
  def read(self, iprot):
18793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18795 
      return
18796 
    iprot.readStructBegin()
18797 
    while True:
18798 
      (fname, ftype, fid) = iprot.readFieldBegin()
18799 
      if ftype == TType.STOP:
18800 
        break
18801 
      if fid == 1:
18802 
        if ftype == TType.STRUCT:
18803 
          self.ex = TransactionServiceException()
18804 
          self.ex.read(iprot)
18805 
        else:
18806 
          iprot.skip(ftype)
18807 
      else:
18808 
        iprot.skip(ftype)
18809 
      iprot.readFieldEnd()
18810 
    iprot.readStructEnd()
18811 
 
18812 
  def write(self, oprot):
18813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18815 
      return
18816 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
18817 
    if self.ex is not None:
18818 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18819 
      self.ex.write(oprot)
18820 
      oprot.writeFieldEnd()
18821 
    oprot.writeFieldStop()
18822 
    oprot.writeStructEnd()
18823 
 
18824 
  def validate(self):
18825 
    return
18826 
 
18827 
 
18828 
  def __repr__(self):
18829 
    L = ['%s=%r' % (key, value)
18830 
      for key, value in self.__dict__.iteritems()]
18831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18832 
 
18833 
  def __eq__(self, other):
18834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18835 
 
18836 
  def __ne__(self, other):
18837 
    return not (self == other)
18838 
 
18839 
class markOrdersAsReversalInitiated_args:
18840 
  """
18841 
  Attributes:
18842 
   - vendorId
18843 
   - itemId
18844 
   - quantity
18845 
   - estimate
4369 rajveer 18846 
   - isReminder
4303 rajveer 18847 
  """
18848 
 
18849 
  thrift_spec = (
18850 
    None, # 0
18851 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18852 
    (2, TType.I64, 'itemId', None, None, ), # 2
18853 
    (3, TType.I64, 'quantity', None, None, ), # 3
18854 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18855 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18856 
  )
18857 
 
4369 rajveer 18858 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18859 
    self.vendorId = vendorId
18860 
    self.itemId = itemId
18861 
    self.quantity = quantity
18862 
    self.estimate = estimate
4369 rajveer 18863 
    self.isReminder = isReminder
4303 rajveer 18864 
 
18865 
  def read(self, iprot):
18866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18868 
      return
18869 
    iprot.readStructBegin()
18870 
    while True:
18871 
      (fname, ftype, fid) = iprot.readFieldBegin()
18872 
      if ftype == TType.STOP:
18873 
        break
18874 
      if fid == 1:
18875 
        if ftype == TType.I64:
18876 
          self.vendorId = iprot.readI64();
18877 
        else:
18878 
          iprot.skip(ftype)
18879 
      elif fid == 2:
18880 
        if ftype == TType.I64:
18881 
          self.itemId = iprot.readI64();
18882 
        else:
18883 
          iprot.skip(ftype)
18884 
      elif fid == 3:
18885 
        if ftype == TType.I64:
18886 
          self.quantity = iprot.readI64();
18887 
        else:
18888 
          iprot.skip(ftype)
18889 
      elif fid == 4:
18890 
        if ftype == TType.I64:
18891 
          self.estimate = iprot.readI64();
18892 
        else:
18893 
          iprot.skip(ftype)
4369 rajveer 18894 
      elif fid == 5:
18895 
        if ftype == TType.BOOL:
18896 
          self.isReminder = iprot.readBool();
18897 
        else:
18898 
          iprot.skip(ftype)
4303 rajveer 18899 
      else:
18900 
        iprot.skip(ftype)
18901 
      iprot.readFieldEnd()
18902 
    iprot.readStructEnd()
18903 
 
18904 
  def write(self, oprot):
18905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18907 
      return
18908 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
18909 
    if self.vendorId is not None:
18910 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18911 
      oprot.writeI64(self.vendorId)
18912 
      oprot.writeFieldEnd()
18913 
    if self.itemId is not None:
18914 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18915 
      oprot.writeI64(self.itemId)
18916 
      oprot.writeFieldEnd()
18917 
    if self.quantity is not None:
18918 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18919 
      oprot.writeI64(self.quantity)
18920 
      oprot.writeFieldEnd()
18921 
    if self.estimate is not None:
18922 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18923 
      oprot.writeI64(self.estimate)
18924 
      oprot.writeFieldEnd()
4369 rajveer 18925 
    if self.isReminder is not None:
18926 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18927 
      oprot.writeBool(self.isReminder)
18928 
      oprot.writeFieldEnd()
4303 rajveer 18929 
    oprot.writeFieldStop()
18930 
    oprot.writeStructEnd()
18931 
 
18932 
  def validate(self):
18933 
    return
18934 
 
18935 
 
18936 
  def __repr__(self):
18937 
    L = ['%s=%r' % (key, value)
18938 
      for key, value in self.__dict__.iteritems()]
18939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18940 
 
18941 
  def __eq__(self, other):
18942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18943 
 
18944 
  def __ne__(self, other):
18945 
    return not (self == other)
18946 
 
18947 
class markOrdersAsReversalInitiated_result:
18948 
  """
18949 
  Attributes:
18950 
   - ex
18951 
  """
18952 
 
18953 
  thrift_spec = (
18954 
    None, # 0
18955 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18956 
  )
18957 
 
18958 
  def __init__(self, ex=None,):
18959 
    self.ex = ex
18960 
 
18961 
  def read(self, iprot):
18962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18964 
      return
18965 
    iprot.readStructBegin()
18966 
    while True:
18967 
      (fname, ftype, fid) = iprot.readFieldBegin()
18968 
      if ftype == TType.STOP:
18969 
        break
18970 
      if fid == 1:
18971 
        if ftype == TType.STRUCT:
18972 
          self.ex = TransactionServiceException()
18973 
          self.ex.read(iprot)
18974 
        else:
18975 
          iprot.skip(ftype)
18976 
      else:
18977 
        iprot.skip(ftype)
18978 
      iprot.readFieldEnd()
18979 
    iprot.readStructEnd()
18980 
 
18981 
  def write(self, oprot):
18982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18984 
      return
18985 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
18986 
    if self.ex is not None:
18987 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18988 
      self.ex.write(oprot)
18989 
      oprot.writeFieldEnd()
18990 
    oprot.writeFieldStop()
18991 
    oprot.writeStructEnd()
18992 
 
18993 
  def validate(self):
18994 
    return
18995 
 
18996 
 
18997 
  def __repr__(self):
18998 
    L = ['%s=%r' % (key, value)
18999 
      for key, value in self.__dict__.iteritems()]
19000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19001 
 
19002 
  def __eq__(self, other):
19003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19004 
 
19005 
  def __ne__(self, other):
19006 
    return not (self == other)
19007 
 
19008 
class markOrdersAsNotAvailabke_args:
19009 
  """
19010 
  Attributes:
19011 
   - vendorId
19012 
   - itemId
19013 
   - quantity
19014 
   - estimate
4369 rajveer 19015 
   - isReminder
4303 rajveer 19016 
  """
19017 
 
19018 
  thrift_spec = (
19019 
    None, # 0
19020 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19021 
    (2, TType.I64, 'itemId', None, None, ), # 2
19022 
    (3, TType.I64, 'quantity', None, None, ), # 3
19023 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 19024 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 19025 
  )
19026 
 
4369 rajveer 19027 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 19028 
    self.vendorId = vendorId
19029 
    self.itemId = itemId
19030 
    self.quantity = quantity
19031 
    self.estimate = estimate
4369 rajveer 19032 
    self.isReminder = isReminder
4303 rajveer 19033 
 
19034 
  def read(self, iprot):
19035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19037 
      return
19038 
    iprot.readStructBegin()
19039 
    while True:
19040 
      (fname, ftype, fid) = iprot.readFieldBegin()
19041 
      if ftype == TType.STOP:
19042 
        break
19043 
      if fid == 1:
19044 
        if ftype == TType.I64:
19045 
          self.vendorId = iprot.readI64();
19046 
        else:
19047 
          iprot.skip(ftype)
19048 
      elif fid == 2:
19049 
        if ftype == TType.I64:
19050 
          self.itemId = iprot.readI64();
19051 
        else:
19052 
          iprot.skip(ftype)
19053 
      elif fid == 3:
19054 
        if ftype == TType.I64:
19055 
          self.quantity = iprot.readI64();
19056 
        else:
19057 
          iprot.skip(ftype)
19058 
      elif fid == 4:
19059 
        if ftype == TType.I64:
19060 
          self.estimate = iprot.readI64();
19061 
        else:
19062 
          iprot.skip(ftype)
4369 rajveer 19063 
      elif fid == 5:
19064 
        if ftype == TType.BOOL:
19065 
          self.isReminder = iprot.readBool();
19066 
        else:
19067 
          iprot.skip(ftype)
4303 rajveer 19068 
      else:
19069 
        iprot.skip(ftype)
19070 
      iprot.readFieldEnd()
19071 
    iprot.readStructEnd()
19072 
 
19073 
  def write(self, oprot):
19074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19076 
      return
19077 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
19078 
    if self.vendorId is not None:
19079 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19080 
      oprot.writeI64(self.vendorId)
19081 
      oprot.writeFieldEnd()
19082 
    if self.itemId is not None:
19083 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19084 
      oprot.writeI64(self.itemId)
19085 
      oprot.writeFieldEnd()
19086 
    if self.quantity is not None:
19087 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
19088 
      oprot.writeI64(self.quantity)
19089 
      oprot.writeFieldEnd()
19090 
    if self.estimate is not None:
19091 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
19092 
      oprot.writeI64(self.estimate)
19093 
      oprot.writeFieldEnd()
4369 rajveer 19094 
    if self.isReminder is not None:
19095 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19096 
      oprot.writeBool(self.isReminder)
19097 
      oprot.writeFieldEnd()
4303 rajveer 19098 
    oprot.writeFieldStop()
19099 
    oprot.writeStructEnd()
19100 
 
19101 
  def validate(self):
19102 
    return
19103 
 
19104 
 
19105 
  def __repr__(self):
19106 
    L = ['%s=%r' % (key, value)
19107 
      for key, value in self.__dict__.iteritems()]
19108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19109 
 
19110 
  def __eq__(self, other):
19111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19112 
 
19113 
  def __ne__(self, other):
19114 
    return not (self == other)
19115 
 
19116 
class markOrdersAsNotAvailabke_result:
19117 
  """
19118 
  Attributes:
19119 
   - ex
19120 
  """
19121 
 
19122 
  thrift_spec = (
19123 
    None, # 0
19124 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19125 
  )
19126 
 
19127 
  def __init__(self, ex=None,):
19128 
    self.ex = ex
19129 
 
19130 
  def read(self, iprot):
19131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19133 
      return
19134 
    iprot.readStructBegin()
19135 
    while True:
19136 
      (fname, ftype, fid) = iprot.readFieldBegin()
19137 
      if ftype == TType.STOP:
19138 
        break
19139 
      if fid == 1:
19140 
        if ftype == TType.STRUCT:
19141 
          self.ex = TransactionServiceException()
19142 
          self.ex.read(iprot)
19143 
        else:
19144 
          iprot.skip(ftype)
19145 
      else:
19146 
        iprot.skip(ftype)
19147 
      iprot.readFieldEnd()
19148 
    iprot.readStructEnd()
19149 
 
19150 
  def write(self, oprot):
19151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19153 
      return
19154 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
19155 
    if self.ex is not None:
19156 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19157 
      self.ex.write(oprot)
19158 
      oprot.writeFieldEnd()
19159 
    oprot.writeFieldStop()
19160 
    oprot.writeStructEnd()
19161 
 
19162 
  def validate(self):
19163 
    return
19164 
 
19165 
 
19166 
  def __repr__(self):
19167 
    L = ['%s=%r' % (key, value)
19168 
      for key, value in self.__dict__.iteritems()]
19169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19170 
 
19171 
  def __eq__(self, other):
19172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19173 
 
19174 
  def __ne__(self, other):
19175 
    return not (self == other)
4369 rajveer 19176 
 
19177 
class markOrdersAsTimeout_args:
19178 
  """
19179 
  Attributes:
19180 
   - vendorId
19181 
  """
19182 
 
19183 
  thrift_spec = (
19184 
    None, # 0
19185 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19186 
  )
19187 
 
19188 
  def __init__(self, vendorId=None,):
19189 
    self.vendorId = vendorId
19190 
 
19191 
  def read(self, iprot):
19192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19194 
      return
19195 
    iprot.readStructBegin()
19196 
    while True:
19197 
      (fname, ftype, fid) = iprot.readFieldBegin()
19198 
      if ftype == TType.STOP:
19199 
        break
19200 
      if fid == 1:
19201 
        if ftype == TType.I64:
19202 
          self.vendorId = iprot.readI64();
19203 
        else:
19204 
          iprot.skip(ftype)
19205 
      else:
19206 
        iprot.skip(ftype)
19207 
      iprot.readFieldEnd()
19208 
    iprot.readStructEnd()
19209 
 
19210 
  def write(self, oprot):
19211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19213 
      return
19214 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
19215 
    if self.vendorId is not None:
19216 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19217 
      oprot.writeI64(self.vendorId)
19218 
      oprot.writeFieldEnd()
19219 
    oprot.writeFieldStop()
19220 
    oprot.writeStructEnd()
19221 
 
19222 
  def validate(self):
19223 
    return
19224 
 
19225 
 
19226 
  def __repr__(self):
19227 
    L = ['%s=%r' % (key, value)
19228 
      for key, value in self.__dict__.iteritems()]
19229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19230 
 
19231 
  def __eq__(self, other):
19232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19233 
 
19234 
  def __ne__(self, other):
19235 
    return not (self == other)
19236 
 
19237 
class markOrdersAsTimeout_result:
19238 
  """
19239 
  Attributes:
19240 
   - success
19241 
   - ex
19242 
  """
19243 
 
19244 
  thrift_spec = (
19245 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
19246 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19247 
  )
19248 
 
19249 
  def __init__(self, success=None, ex=None,):
19250 
    self.success = success
19251 
    self.ex = ex
19252 
 
19253 
  def read(self, iprot):
19254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19256 
      return
19257 
    iprot.readStructBegin()
19258 
    while True:
19259 
      (fname, ftype, fid) = iprot.readFieldBegin()
19260 
      if ftype == TType.STOP:
19261 
        break
19262 
      if fid == 0:
19263 
        if ftype == TType.MAP:
19264 
          self.success = {}
5031 varun.gupt 19265 
          (_ktype410, _vtype411, _size409 ) = iprot.readMapBegin()
19266 
          for _i413 in xrange(_size409):
19267 
            _key414 = iprot.readI32();
19268 
            _val415 = TimeoutSummary()
19269 
            _val415.read(iprot)
19270 
            self.success[_key414] = _val415
4369 rajveer 19271 
          iprot.readMapEnd()
19272 
        else:
19273 
          iprot.skip(ftype)
19274 
      elif fid == 1:
19275 
        if ftype == TType.STRUCT:
19276 
          self.ex = TransactionServiceException()
19277 
          self.ex.read(iprot)
19278 
        else:
19279 
          iprot.skip(ftype)
19280 
      else:
19281 
        iprot.skip(ftype)
19282 
      iprot.readFieldEnd()
19283 
    iprot.readStructEnd()
19284 
 
19285 
  def write(self, oprot):
19286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19288 
      return
19289 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
19290 
    if self.success is not None:
19291 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19292 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
5031 varun.gupt 19293 
      for kiter416,viter417 in self.success.items():
19294 
        oprot.writeI32(kiter416)
19295 
        viter417.write(oprot)
4369 rajveer 19296 
      oprot.writeMapEnd()
19297 
      oprot.writeFieldEnd()
19298 
    if self.ex is not None:
19299 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19300 
      self.ex.write(oprot)
19301 
      oprot.writeFieldEnd()
19302 
    oprot.writeFieldStop()
19303 
    oprot.writeStructEnd()
19304 
 
19305 
  def validate(self):
19306 
    return
19307 
 
19308 
 
19309 
  def __repr__(self):
19310 
    L = ['%s=%r' % (key, value)
19311 
      for key, value in self.__dict__.iteritems()]
19312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19313 
 
19314 
  def __eq__(self, other):
19315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19316 
 
19317 
  def __ne__(self, other):
19318 
    return not (self == other)
4386 anupam.sin 19319 
 
4662 rajveer 19320 
class markOrderAsLostInTransit_args:
19321 
  """
19322 
  Attributes:
19323 
   - orderId
19324 
  """
19325 
 
19326 
  thrift_spec = (
19327 
    None, # 0
19328 
    (1, TType.I64, 'orderId', None, None, ), # 1
19329 
  )
19330 
 
19331 
  def __init__(self, orderId=None,):
19332 
    self.orderId = orderId
19333 
 
19334 
  def read(self, iprot):
19335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19337 
      return
19338 
    iprot.readStructBegin()
19339 
    while True:
19340 
      (fname, ftype, fid) = iprot.readFieldBegin()
19341 
      if ftype == TType.STOP:
19342 
        break
19343 
      if fid == 1:
19344 
        if ftype == TType.I64:
19345 
          self.orderId = iprot.readI64();
19346 
        else:
19347 
          iprot.skip(ftype)
19348 
      else:
19349 
        iprot.skip(ftype)
19350 
      iprot.readFieldEnd()
19351 
    iprot.readStructEnd()
19352 
 
19353 
  def write(self, oprot):
19354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19356 
      return
19357 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
19358 
    if self.orderId is not None:
19359 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19360 
      oprot.writeI64(self.orderId)
19361 
      oprot.writeFieldEnd()
19362 
    oprot.writeFieldStop()
19363 
    oprot.writeStructEnd()
19364 
 
19365 
  def validate(self):
19366 
    return
19367 
 
19368 
 
19369 
  def __repr__(self):
19370 
    L = ['%s=%r' % (key, value)
19371 
      for key, value in self.__dict__.iteritems()]
19372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19373 
 
19374 
  def __eq__(self, other):
19375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19376 
 
19377 
  def __ne__(self, other):
19378 
    return not (self == other)
19379 
 
19380 
class markOrderAsLostInTransit_result:
19381 
  """
19382 
  Attributes:
19383 
   - success
19384 
   - ex
19385 
  """
19386 
 
19387 
  thrift_spec = (
19388 
    (0, TType.BOOL, 'success', None, None, ), # 0
19389 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19390 
  )
19391 
 
19392 
  def __init__(self, success=None, ex=None,):
19393 
    self.success = success
19394 
    self.ex = ex
19395 
 
19396 
  def read(self, iprot):
19397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19399 
      return
19400 
    iprot.readStructBegin()
19401 
    while True:
19402 
      (fname, ftype, fid) = iprot.readFieldBegin()
19403 
      if ftype == TType.STOP:
19404 
        break
19405 
      if fid == 0:
19406 
        if ftype == TType.BOOL:
19407 
          self.success = iprot.readBool();
19408 
        else:
19409 
          iprot.skip(ftype)
19410 
      elif fid == 1:
19411 
        if ftype == TType.STRUCT:
19412 
          self.ex = TransactionServiceException()
19413 
          self.ex.read(iprot)
19414 
        else:
19415 
          iprot.skip(ftype)
19416 
      else:
19417 
        iprot.skip(ftype)
19418 
      iprot.readFieldEnd()
19419 
    iprot.readStructEnd()
19420 
 
19421 
  def write(self, oprot):
19422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19424 
      return
19425 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
19426 
    if self.success is not None:
19427 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19428 
      oprot.writeBool(self.success)
19429 
      oprot.writeFieldEnd()
19430 
    if self.ex is not None:
19431 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19432 
      self.ex.write(oprot)
19433 
      oprot.writeFieldEnd()
19434 
    oprot.writeFieldStop()
19435 
    oprot.writeStructEnd()
19436 
 
19437 
  def validate(self):
19438 
    return
19439 
 
19440 
 
19441 
  def __repr__(self):
19442 
    L = ['%s=%r' % (key, value)
19443 
      for key, value in self.__dict__.iteritems()]
19444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19445 
 
19446 
  def __eq__(self, other):
19447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19448 
 
19449 
  def __ne__(self, other):
19450 
    return not (self == other)
19451 
 
4386 anupam.sin 19452 
class getOrderForAwb_args:
19453 
  """
19454 
  Attributes:
19455 
   - awb
19456 
  """
19457 
 
19458 
  thrift_spec = (
19459 
    None, # 0
19460 
    (1, TType.STRING, 'awb', None, None, ), # 1
19461 
  )
19462 
 
19463 
  def __init__(self, awb=None,):
19464 
    self.awb = awb
19465 
 
19466 
  def read(self, iprot):
19467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19469 
      return
19470 
    iprot.readStructBegin()
19471 
    while True:
19472 
      (fname, ftype, fid) = iprot.readFieldBegin()
19473 
      if ftype == TType.STOP:
19474 
        break
19475 
      if fid == 1:
19476 
        if ftype == TType.STRING:
19477 
          self.awb = iprot.readString();
19478 
        else:
19479 
          iprot.skip(ftype)
19480 
      else:
19481 
        iprot.skip(ftype)
19482 
      iprot.readFieldEnd()
19483 
    iprot.readStructEnd()
19484 
 
19485 
  def write(self, oprot):
19486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19488 
      return
19489 
    oprot.writeStructBegin('getOrderForAwb_args')
19490 
    if self.awb is not None:
19491 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
19492 
      oprot.writeString(self.awb)
19493 
      oprot.writeFieldEnd()
19494 
    oprot.writeFieldStop()
19495 
    oprot.writeStructEnd()
19496 
 
19497 
  def validate(self):
19498 
    return
19499 
 
19500 
 
19501 
  def __repr__(self):
19502 
    L = ['%s=%r' % (key, value)
19503 
      for key, value in self.__dict__.iteritems()]
19504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19505 
 
19506 
  def __eq__(self, other):
19507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19508 
 
19509 
  def __ne__(self, other):
19510 
    return not (self == other)
19511 
 
19512 
class getOrderForAwb_result:
19513 
  """
19514 
  Attributes:
19515 
   - success
19516 
   - ex
19517 
  """
19518 
 
19519 
  thrift_spec = (
19520 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19521 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19522 
  )
19523 
 
19524 
  def __init__(self, success=None, ex=None,):
19525 
    self.success = success
19526 
    self.ex = ex
19527 
 
19528 
  def read(self, iprot):
19529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19531 
      return
19532 
    iprot.readStructBegin()
19533 
    while True:
19534 
      (fname, ftype, fid) = iprot.readFieldBegin()
19535 
      if ftype == TType.STOP:
19536 
        break
19537 
      if fid == 0:
19538 
        if ftype == TType.STRUCT:
19539 
          self.success = Order()
19540 
          self.success.read(iprot)
19541 
        else:
19542 
          iprot.skip(ftype)
19543 
      elif fid == 1:
19544 
        if ftype == TType.STRUCT:
19545 
          self.ex = TransactionServiceException()
19546 
          self.ex.read(iprot)
19547 
        else:
19548 
          iprot.skip(ftype)
19549 
      else:
19550 
        iprot.skip(ftype)
19551 
      iprot.readFieldEnd()
19552 
    iprot.readStructEnd()
19553 
 
19554 
  def write(self, oprot):
19555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19557 
      return
19558 
    oprot.writeStructBegin('getOrderForAwb_result')
19559 
    if self.success is not None:
19560 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19561 
      self.success.write(oprot)
19562 
      oprot.writeFieldEnd()
19563 
    if self.ex is not None:
19564 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19565 
      self.ex.write(oprot)
19566 
      oprot.writeFieldEnd()
19567 
    oprot.writeFieldStop()
19568 
    oprot.writeStructEnd()
19569 
 
19570 
  def validate(self):
19571 
    return
19572 
 
19573 
 
19574 
  def __repr__(self):
19575 
    L = ['%s=%r' % (key, value)
19576 
      for key, value in self.__dict__.iteritems()]
19577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19578 
 
19579 
  def __eq__(self, other):
19580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19581 
 
19582 
  def __ne__(self, other):
19583 
    return not (self == other)
4506 phani.kuma 19584 
 
19585 
class getOrdersForProviderForStatus_args:
19586 
  """
19587 
  Attributes:
19588 
   - logistics_provider_id
4910 phani.kuma 19589 
   - order_status_list
4506 phani.kuma 19590 
  """
19591 
 
19592 
  thrift_spec = (
19593 
    None, # 0
19594 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 19595 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 19596 
  )
19597 
 
4910 phani.kuma 19598 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 19599 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 19600 
    self.order_status_list = order_status_list
4506 phani.kuma 19601 
 
19602 
  def read(self, iprot):
19603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19605 
      return
19606 
    iprot.readStructBegin()
19607 
    while True:
19608 
      (fname, ftype, fid) = iprot.readFieldBegin()
19609 
      if ftype == TType.STOP:
19610 
        break
19611 
      if fid == 1:
19612 
        if ftype == TType.I64:
19613 
          self.logistics_provider_id = iprot.readI64();
19614 
        else:
19615 
          iprot.skip(ftype)
19616 
      elif fid == 2:
4910 phani.kuma 19617 
        if ftype == TType.LIST:
19618 
          self.order_status_list = []
5031 varun.gupt 19619 
          (_etype421, _size418) = iprot.readListBegin()
19620 
          for _i422 in xrange(_size418):
19621 
            _elem423 = iprot.readI32();
19622 
            self.order_status_list.append(_elem423)
4910 phani.kuma 19623 
          iprot.readListEnd()
4506 phani.kuma 19624 
        else:
19625 
          iprot.skip(ftype)
19626 
      else:
19627 
        iprot.skip(ftype)
19628 
      iprot.readFieldEnd()
19629 
    iprot.readStructEnd()
19630 
 
19631 
  def write(self, oprot):
19632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19634 
      return
19635 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
19636 
    if self.logistics_provider_id is not None:
19637 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
19638 
      oprot.writeI64(self.logistics_provider_id)
19639 
      oprot.writeFieldEnd()
4910 phani.kuma 19640 
    if self.order_status_list is not None:
19641 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
19642 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
5031 varun.gupt 19643 
      for iter424 in self.order_status_list:
19644 
        oprot.writeI32(iter424)
4910 phani.kuma 19645 
      oprot.writeListEnd()
4506 phani.kuma 19646 
      oprot.writeFieldEnd()
19647 
    oprot.writeFieldStop()
19648 
    oprot.writeStructEnd()
19649 
 
19650 
  def validate(self):
19651 
    return
19652 
 
19653 
 
19654 
  def __repr__(self):
19655 
    L = ['%s=%r' % (key, value)
19656 
      for key, value in self.__dict__.iteritems()]
19657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19658 
 
19659 
  def __eq__(self, other):
19660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19661 
 
19662 
  def __ne__(self, other):
19663 
    return not (self == other)
19664 
 
19665 
class getOrdersForProviderForStatus_result:
19666 
  """
19667 
  Attributes:
19668 
   - success
19669 
   - ex
19670 
  """
19671 
 
19672 
  thrift_spec = (
19673 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19674 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19675 
  )
19676 
 
19677 
  def __init__(self, success=None, ex=None,):
19678 
    self.success = success
19679 
    self.ex = ex
19680 
 
19681 
  def read(self, iprot):
19682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19684 
      return
19685 
    iprot.readStructBegin()
19686 
    while True:
19687 
      (fname, ftype, fid) = iprot.readFieldBegin()
19688 
      if ftype == TType.STOP:
19689 
        break
19690 
      if fid == 0:
19691 
        if ftype == TType.LIST:
19692 
          self.success = []
5031 varun.gupt 19693 
          (_etype428, _size425) = iprot.readListBegin()
19694 
          for _i429 in xrange(_size425):
19695 
            _elem430 = Order()
19696 
            _elem430.read(iprot)
19697 
            self.success.append(_elem430)
4506 phani.kuma 19698 
          iprot.readListEnd()
19699 
        else:
19700 
          iprot.skip(ftype)
19701 
      elif fid == 1:
19702 
        if ftype == TType.STRUCT:
19703 
          self.ex = TransactionServiceException()
19704 
          self.ex.read(iprot)
19705 
        else:
19706 
          iprot.skip(ftype)
19707 
      else:
19708 
        iprot.skip(ftype)
19709 
      iprot.readFieldEnd()
19710 
    iprot.readStructEnd()
19711 
 
19712 
  def write(self, oprot):
19713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19715 
      return
19716 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
19717 
    if self.success is not None:
19718 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19719 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19720 
      for iter431 in self.success:
19721 
        iter431.write(oprot)
4506 phani.kuma 19722 
      oprot.writeListEnd()
19723 
      oprot.writeFieldEnd()
19724 
    if self.ex is not None:
19725 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19726 
      self.ex.write(oprot)
19727 
      oprot.writeFieldEnd()
19728 
    oprot.writeFieldStop()
19729 
    oprot.writeStructEnd()
19730 
 
19731 
  def validate(self):
19732 
    return
19733 
 
19734 
 
19735 
  def __repr__(self):
19736 
    L = ['%s=%r' % (key, value)
19737 
      for key, value in self.__dict__.iteritems()]
19738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19739 
 
19740 
  def __eq__(self, other):
19741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19742 
 
19743 
  def __ne__(self, other):
19744 
    return not (self == other)
4600 varun.gupt 19745 
 
19746 
class getBilledOrdersForVendor_args:
19747 
  """
19748 
  Attributes:
19749 
   - vendorId
19750 
   - billingDateFrom
19751 
   - billingDateTo
19752 
  """
19753 
 
19754 
  thrift_spec = (
19755 
    None, # 0
19756 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19757 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
19758 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
19759 
  )
19760 
 
19761 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
19762 
    self.vendorId = vendorId
19763 
    self.billingDateFrom = billingDateFrom
19764 
    self.billingDateTo = billingDateTo
19765 
 
19766 
  def read(self, iprot):
19767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19769 
      return
19770 
    iprot.readStructBegin()
19771 
    while True:
19772 
      (fname, ftype, fid) = iprot.readFieldBegin()
19773 
      if ftype == TType.STOP:
19774 
        break
19775 
      if fid == 1:
19776 
        if ftype == TType.I64:
19777 
          self.vendorId = iprot.readI64();
19778 
        else:
19779 
          iprot.skip(ftype)
19780 
      elif fid == 2:
19781 
        if ftype == TType.I64:
19782 
          self.billingDateFrom = iprot.readI64();
19783 
        else:
19784 
          iprot.skip(ftype)
19785 
      elif fid == 3:
19786 
        if ftype == TType.I64:
19787 
          self.billingDateTo = iprot.readI64();
19788 
        else:
19789 
          iprot.skip(ftype)
19790 
      else:
19791 
        iprot.skip(ftype)
19792 
      iprot.readFieldEnd()
19793 
    iprot.readStructEnd()
19794 
 
19795 
  def write(self, oprot):
19796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19798 
      return
19799 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
19800 
    if self.vendorId is not None:
19801 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19802 
      oprot.writeI64(self.vendorId)
19803 
      oprot.writeFieldEnd()
19804 
    if self.billingDateFrom is not None:
19805 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
19806 
      oprot.writeI64(self.billingDateFrom)
19807 
      oprot.writeFieldEnd()
19808 
    if self.billingDateTo is not None:
19809 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
19810 
      oprot.writeI64(self.billingDateTo)
19811 
      oprot.writeFieldEnd()
19812 
    oprot.writeFieldStop()
19813 
    oprot.writeStructEnd()
19814 
 
19815 
  def validate(self):
19816 
    return
19817 
 
19818 
 
19819 
  def __repr__(self):
19820 
    L = ['%s=%r' % (key, value)
19821 
      for key, value in self.__dict__.iteritems()]
19822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19823 
 
19824 
  def __eq__(self, other):
19825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19826 
 
19827 
  def __ne__(self, other):
19828 
    return not (self == other)
19829 
 
19830 
class getBilledOrdersForVendor_result:
19831 
  """
19832 
  Attributes:
19833 
   - success
19834 
   - ex
19835 
  """
19836 
 
19837 
  thrift_spec = (
19838 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19839 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19840 
  )
19841 
 
19842 
  def __init__(self, success=None, ex=None,):
19843 
    self.success = success
19844 
    self.ex = ex
19845 
 
19846 
  def read(self, iprot):
19847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19849 
      return
19850 
    iprot.readStructBegin()
19851 
    while True:
19852 
      (fname, ftype, fid) = iprot.readFieldBegin()
19853 
      if ftype == TType.STOP:
19854 
        break
19855 
      if fid == 0:
19856 
        if ftype == TType.LIST:
19857 
          self.success = []
5031 varun.gupt 19858 
          (_etype435, _size432) = iprot.readListBegin()
19859 
          for _i436 in xrange(_size432):
19860 
            _elem437 = Order()
19861 
            _elem437.read(iprot)
19862 
            self.success.append(_elem437)
4600 varun.gupt 19863 
          iprot.readListEnd()
19864 
        else:
19865 
          iprot.skip(ftype)
19866 
      elif fid == 1:
19867 
        if ftype == TType.STRUCT:
19868 
          self.ex = TransactionServiceException()
19869 
          self.ex.read(iprot)
19870 
        else:
19871 
          iprot.skip(ftype)
19872 
      else:
19873 
        iprot.skip(ftype)
19874 
      iprot.readFieldEnd()
19875 
    iprot.readStructEnd()
19876 
 
19877 
  def write(self, oprot):
19878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19880 
      return
19881 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
19882 
    if self.success is not None:
19883 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19884 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19885 
      for iter438 in self.success:
19886 
        iter438.write(oprot)
4600 varun.gupt 19887 
      oprot.writeListEnd()
19888 
      oprot.writeFieldEnd()
19889 
    if self.ex is not None:
19890 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19891 
      self.ex.write(oprot)
19892 
      oprot.writeFieldEnd()
19893 
    oprot.writeFieldStop()
19894 
    oprot.writeStructEnd()
19895 
 
19896 
  def validate(self):
19897 
    return
19898 
 
19899 
 
19900 
  def __repr__(self):
19901 
    L = ['%s=%r' % (key, value)
19902 
      for key, value in self.__dict__.iteritems()]
19903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19904 
 
19905 
  def __eq__(self, other):
19906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19907 
 
19908 
  def __ne__(self, other):
19909 
    return not (self == other)
19910 
 
4607 rajveer 19911 
class getSlippedSippingDateOrders_args:
19912 
 
19913 
  thrift_spec = (
19914 
  )
19915 
 
19916 
  def read(self, iprot):
19917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19919 
      return
19920 
    iprot.readStructBegin()
19921 
    while True:
19922 
      (fname, ftype, fid) = iprot.readFieldBegin()
19923 
      if ftype == TType.STOP:
19924 
        break
19925 
      else:
19926 
        iprot.skip(ftype)
19927 
      iprot.readFieldEnd()
19928 
    iprot.readStructEnd()
19929 
 
19930 
  def write(self, oprot):
19931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19933 
      return
19934 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
19935 
    oprot.writeFieldStop()
19936 
    oprot.writeStructEnd()
19937 
 
19938 
  def validate(self):
19939 
    return
19940 
 
19941 
 
19942 
  def __repr__(self):
19943 
    L = ['%s=%r' % (key, value)
19944 
      for key, value in self.__dict__.iteritems()]
19945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19946 
 
19947 
  def __eq__(self, other):
19948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19949 
 
19950 
  def __ne__(self, other):
19951 
    return not (self == other)
19952 
 
19953 
class getSlippedSippingDateOrders_result:
19954 
  """
19955 
  Attributes:
19956 
   - success
19957 
   - ex
19958 
  """
19959 
 
19960 
  thrift_spec = (
19961 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19962 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19963 
  )
19964 
 
19965 
  def __init__(self, success=None, ex=None,):
19966 
    self.success = success
19967 
    self.ex = ex
19968 
 
19969 
  def read(self, iprot):
19970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19972 
      return
19973 
    iprot.readStructBegin()
19974 
    while True:
19975 
      (fname, ftype, fid) = iprot.readFieldBegin()
19976 
      if ftype == TType.STOP:
19977 
        break
19978 
      if fid == 0:
19979 
        if ftype == TType.LIST:
19980 
          self.success = []
5031 varun.gupt 19981 
          (_etype442, _size439) = iprot.readListBegin()
19982 
          for _i443 in xrange(_size439):
19983 
            _elem444 = Order()
19984 
            _elem444.read(iprot)
19985 
            self.success.append(_elem444)
4607 rajveer 19986 
          iprot.readListEnd()
19987 
        else:
19988 
          iprot.skip(ftype)
19989 
      elif fid == 1:
19990 
        if ftype == TType.STRUCT:
19991 
          self.ex = TransactionServiceException()
19992 
          self.ex.read(iprot)
19993 
        else:
19994 
          iprot.skip(ftype)
19995 
      else:
19996 
        iprot.skip(ftype)
19997 
      iprot.readFieldEnd()
19998 
    iprot.readStructEnd()
19999 
 
20000 
  def write(self, oprot):
20001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20003 
      return
20004 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
20005 
    if self.success is not None:
20006 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20007 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 20008 
      for iter445 in self.success:
20009 
        iter445.write(oprot)
4607 rajveer 20010 
      oprot.writeListEnd()
20011 
      oprot.writeFieldEnd()
20012 
    if self.ex is not None:
20013 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20014 
      self.ex.write(oprot)
20015 
      oprot.writeFieldEnd()
20016 
    oprot.writeFieldStop()
20017 
    oprot.writeStructEnd()
20018 
 
20019 
  def validate(self):
20020 
    return
20021 
 
20022 
 
20023 
  def __repr__(self):
20024 
    L = ['%s=%r' % (key, value)
20025 
      for key, value in self.__dict__.iteritems()]
20026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20027 
 
20028 
  def __eq__(self, other):
20029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20030 
 
20031 
  def __ne__(self, other):
20032 
    return not (self == other)
20033 
 
4709 rajveer 20034 
class getCancelledOrders_args:
20035 
  """
20036 
  Attributes:
20037 
   - cancelDateFrom
20038 
   - cancelDateTo
20039 
  """
20040 
 
20041 
  thrift_spec = (
20042 
    None, # 0
20043 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
20044 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
20045 
  )
20046 
 
20047 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
20048 
    self.cancelDateFrom = cancelDateFrom
20049 
    self.cancelDateTo = cancelDateTo
20050 
 
20051 
  def read(self, iprot):
20052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20054 
      return
20055 
    iprot.readStructBegin()
20056 
    while True:
20057 
      (fname, ftype, fid) = iprot.readFieldBegin()
20058 
      if ftype == TType.STOP:
20059 
        break
20060 
      if fid == 1:
20061 
        if ftype == TType.I64:
20062 
          self.cancelDateFrom = iprot.readI64();
20063 
        else:
20064 
          iprot.skip(ftype)
20065 
      elif fid == 2:
20066 
        if ftype == TType.I64:
20067 
          self.cancelDateTo = iprot.readI64();
20068 
        else:
20069 
          iprot.skip(ftype)
20070 
      else:
20071 
        iprot.skip(ftype)
20072 
      iprot.readFieldEnd()
20073 
    iprot.readStructEnd()
20074 
 
20075 
  def write(self, oprot):
20076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20078 
      return
20079 
    oprot.writeStructBegin('getCancelledOrders_args')
20080 
    if self.cancelDateFrom is not None:
20081 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
20082 
      oprot.writeI64(self.cancelDateFrom)
20083 
      oprot.writeFieldEnd()
20084 
    if self.cancelDateTo is not None:
20085 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
20086 
      oprot.writeI64(self.cancelDateTo)
20087 
      oprot.writeFieldEnd()
20088 
    oprot.writeFieldStop()
20089 
    oprot.writeStructEnd()
20090 
 
20091 
  def validate(self):
20092 
    return
20093 
 
20094 
 
20095 
  def __repr__(self):
20096 
    L = ['%s=%r' % (key, value)
20097 
      for key, value in self.__dict__.iteritems()]
20098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20099 
 
20100 
  def __eq__(self, other):
20101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20102 
 
20103 
  def __ne__(self, other):
20104 
    return not (self == other)
20105 
 
20106 
class getCancelledOrders_result:
20107 
  """
20108 
  Attributes:
20109 
   - success
20110 
   - ex
20111 
  """
20112 
 
20113 
  thrift_spec = (
20114 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20115 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20116 
  )
20117 
 
20118 
  def __init__(self, success=None, ex=None,):
20119 
    self.success = success
20120 
    self.ex = ex
20121 
 
20122 
  def read(self, iprot):
20123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20125 
      return
20126 
    iprot.readStructBegin()
20127 
    while True:
20128 
      (fname, ftype, fid) = iprot.readFieldBegin()
20129 
      if ftype == TType.STOP:
20130 
        break
20131 
      if fid == 0:
20132 
        if ftype == TType.LIST:
20133 
          self.success = []
5031 varun.gupt 20134 
          (_etype449, _size446) = iprot.readListBegin()
20135 
          for _i450 in xrange(_size446):
20136 
            _elem451 = Order()
20137 
            _elem451.read(iprot)
20138 
            self.success.append(_elem451)
4709 rajveer 20139 
          iprot.readListEnd()
20140 
        else:
20141 
          iprot.skip(ftype)
20142 
      elif fid == 1:
20143 
        if ftype == TType.STRUCT:
20144 
          self.ex = TransactionServiceException()
20145 
          self.ex.read(iprot)
20146 
        else:
20147 
          iprot.skip(ftype)
20148 
      else:
20149 
        iprot.skip(ftype)
20150 
      iprot.readFieldEnd()
20151 
    iprot.readStructEnd()
20152 
 
20153 
  def write(self, oprot):
20154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20156 
      return
20157 
    oprot.writeStructBegin('getCancelledOrders_result')
20158 
    if self.success is not None:
20159 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20160 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 20161 
      for iter452 in self.success:
20162 
        iter452.write(oprot)
4709 rajveer 20163 
      oprot.writeListEnd()
20164 
      oprot.writeFieldEnd()
20165 
    if self.ex is not None:
20166 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20167 
      self.ex.write(oprot)
20168 
      oprot.writeFieldEnd()
20169 
    oprot.writeFieldStop()
20170 
    oprot.writeStructEnd()
20171 
 
20172 
  def validate(self):
20173 
    return
20174 
 
20175 
 
20176 
  def __repr__(self):
20177 
    L = ['%s=%r' % (key, value)
20178 
      for key, value in self.__dict__.iteritems()]
20179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20180 
 
20181 
  def __eq__(self, other):
20182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20183 
 
20184 
  def __ne__(self, other):
20185 
    return not (self == other)
20186 
 
4600 varun.gupt 20187 
class saveBluedartSettlements_args:
20188 
  """
20189 
  Attributes:
20190 
   - mapAWBAndAmount
20191 
  """
20192 
 
20193 
  thrift_spec = (
20194 
    None, # 0
20195 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
20196 
  )
20197 
 
20198 
  def __init__(self, mapAWBAndAmount=None,):
20199 
    self.mapAWBAndAmount = mapAWBAndAmount
20200 
 
20201 
  def read(self, iprot):
20202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20204 
      return
20205 
    iprot.readStructBegin()
20206 
    while True:
20207 
      (fname, ftype, fid) = iprot.readFieldBegin()
20208 
      if ftype == TType.STOP:
20209 
        break
20210 
      if fid == 1:
20211 
        if ftype == TType.MAP:
20212 
          self.mapAWBAndAmount = {}
5031 varun.gupt 20213 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
20214 
          for _i457 in xrange(_size453):
20215 
            _key458 = iprot.readI64();
20216 
            _val459 = iprot.readDouble();
20217 
            self.mapAWBAndAmount[_key458] = _val459
4600 varun.gupt 20218 
          iprot.readMapEnd()
20219 
        else:
20220 
          iprot.skip(ftype)
20221 
      else:
20222 
        iprot.skip(ftype)
20223 
      iprot.readFieldEnd()
20224 
    iprot.readStructEnd()
20225 
 
20226 
  def write(self, oprot):
20227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20229 
      return
20230 
    oprot.writeStructBegin('saveBluedartSettlements_args')
20231 
    if self.mapAWBAndAmount is not None:
20232 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
20233 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
5031 varun.gupt 20234 
      for kiter460,viter461 in self.mapAWBAndAmount.items():
20235 
        oprot.writeI64(kiter460)
20236 
        oprot.writeDouble(viter461)
4600 varun.gupt 20237 
      oprot.writeMapEnd()
20238 
      oprot.writeFieldEnd()
20239 
    oprot.writeFieldStop()
20240 
    oprot.writeStructEnd()
20241 
 
20242 
  def validate(self):
20243 
    return
20244 
 
20245 
 
20246 
  def __repr__(self):
20247 
    L = ['%s=%r' % (key, value)
20248 
      for key, value in self.__dict__.iteritems()]
20249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20250 
 
20251 
  def __eq__(self, other):
20252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20253 
 
20254 
  def __ne__(self, other):
20255 
    return not (self == other)
20256 
 
20257 
class saveBluedartSettlements_result:
20258 
  """
20259 
  Attributes:
20260 
   - ex
20261 
  """
20262 
 
20263 
  thrift_spec = (
20264 
    None, # 0
20265 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20266 
  )
20267 
 
20268 
  def __init__(self, ex=None,):
20269 
    self.ex = ex
20270 
 
20271 
  def read(self, iprot):
20272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20274 
      return
20275 
    iprot.readStructBegin()
20276 
    while True:
20277 
      (fname, ftype, fid) = iprot.readFieldBegin()
20278 
      if ftype == TType.STOP:
20279 
        break
20280 
      if fid == 1:
20281 
        if ftype == TType.STRUCT:
20282 
          self.ex = TransactionServiceException()
20283 
          self.ex.read(iprot)
20284 
        else:
20285 
          iprot.skip(ftype)
20286 
      else:
20287 
        iprot.skip(ftype)
20288 
      iprot.readFieldEnd()
20289 
    iprot.readStructEnd()
20290 
 
20291 
  def write(self, oprot):
20292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20294 
      return
20295 
    oprot.writeStructBegin('saveBluedartSettlements_result')
20296 
    if self.ex is not None:
20297 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20298 
      self.ex.write(oprot)
20299 
      oprot.writeFieldEnd()
20300 
    oprot.writeFieldStop()
20301 
    oprot.writeStructEnd()
20302 
 
20303 
  def validate(self):
20304 
    return
20305 
 
20306 
 
20307 
  def __repr__(self):
20308 
    L = ['%s=%r' % (key, value)
20309 
      for key, value in self.__dict__.iteritems()]
20310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20311 
 
20312 
  def __eq__(self, other):
20313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20314 
 
20315 
  def __ne__(self, other):
20316 
    return not (self == other)
20317 
 
20318 
class savePaymentSettlements_args:
20319 
  """
20320 
  Attributes:
20321 
   - settlementDate
20322 
   - paymentGatewayId
4905 varun.gupt 20323 
   - referenceId
4600 varun.gupt 20324 
   - serviceTax
20325 
   - otherCharges
20326 
   - netCollection
20327 
  """
20328 
 
20329 
  thrift_spec = (
20330 
    None, # 0
20331 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
20332 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 20333 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 20334 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
20335 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
20336 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
20337 
  )
20338 
 
4905 varun.gupt 20339 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 20340 
    self.settlementDate = settlementDate
20341 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 20342 
    self.referenceId = referenceId
4600 varun.gupt 20343 
    self.serviceTax = serviceTax
20344 
    self.otherCharges = otherCharges
20345 
    self.netCollection = netCollection
20346 
 
20347 
  def read(self, iprot):
20348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20350 
      return
20351 
    iprot.readStructBegin()
20352 
    while True:
20353 
      (fname, ftype, fid) = iprot.readFieldBegin()
20354 
      if ftype == TType.STOP:
20355 
        break
20356 
      if fid == 1:
20357 
        if ftype == TType.I64:
20358 
          self.settlementDate = iprot.readI64();
20359 
        else:
20360 
          iprot.skip(ftype)
20361 
      elif fid == 2:
20362 
        if ftype == TType.I64:
20363 
          self.paymentGatewayId = iprot.readI64();
20364 
        else:
20365 
          iprot.skip(ftype)
20366 
      elif fid == 3:
20367 
        if ftype == TType.I64:
4905 varun.gupt 20368 
          self.referenceId = iprot.readI64();
4600 varun.gupt 20369 
        else:
20370 
          iprot.skip(ftype)
20371 
      elif fid == 4:
20372 
        if ftype == TType.DOUBLE:
20373 
          self.serviceTax = iprot.readDouble();
20374 
        else:
20375 
          iprot.skip(ftype)
20376 
      elif fid == 5:
20377 
        if ftype == TType.DOUBLE:
20378 
          self.otherCharges = iprot.readDouble();
20379 
        else:
20380 
          iprot.skip(ftype)
20381 
      elif fid == 6:
20382 
        if ftype == TType.DOUBLE:
20383 
          self.netCollection = iprot.readDouble();
20384 
        else:
20385 
          iprot.skip(ftype)
20386 
      else:
20387 
        iprot.skip(ftype)
20388 
      iprot.readFieldEnd()
20389 
    iprot.readStructEnd()
20390 
 
20391 
  def write(self, oprot):
20392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20394 
      return
20395 
    oprot.writeStructBegin('savePaymentSettlements_args')
20396 
    if self.settlementDate is not None:
20397 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
20398 
      oprot.writeI64(self.settlementDate)
20399 
      oprot.writeFieldEnd()
20400 
    if self.paymentGatewayId is not None:
20401 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
20402 
      oprot.writeI64(self.paymentGatewayId)
20403 
      oprot.writeFieldEnd()
4905 varun.gupt 20404 
    if self.referenceId is not None:
20405 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
20406 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 20407 
      oprot.writeFieldEnd()
20408 
    if self.serviceTax is not None:
20409 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
20410 
      oprot.writeDouble(self.serviceTax)
20411 
      oprot.writeFieldEnd()
20412 
    if self.otherCharges is not None:
20413 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
20414 
      oprot.writeDouble(self.otherCharges)
20415 
      oprot.writeFieldEnd()
20416 
    if self.netCollection is not None:
20417 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
20418 
      oprot.writeDouble(self.netCollection)
20419 
      oprot.writeFieldEnd()
20420 
    oprot.writeFieldStop()
20421 
    oprot.writeStructEnd()
20422 
 
20423 
  def validate(self):
20424 
    return
20425 
 
20426 
 
20427 
  def __repr__(self):
20428 
    L = ['%s=%r' % (key, value)
20429 
      for key, value in self.__dict__.iteritems()]
20430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20431 
 
20432 
  def __eq__(self, other):
20433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20434 
 
20435 
  def __ne__(self, other):
20436 
    return not (self == other)
20437 
 
20438 
class savePaymentSettlements_result:
20439 
  """
20440 
  Attributes:
20441 
   - ex
20442 
  """
20443 
 
20444 
  thrift_spec = (
20445 
    None, # 0
20446 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20447 
  )
20448 
 
20449 
  def __init__(self, ex=None,):
20450 
    self.ex = ex
20451 
 
20452 
  def read(self, iprot):
20453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20455 
      return
20456 
    iprot.readStructBegin()
20457 
    while True:
20458 
      (fname, ftype, fid) = iprot.readFieldBegin()
20459 
      if ftype == TType.STOP:
20460 
        break
20461 
      if fid == 1:
20462 
        if ftype == TType.STRUCT:
20463 
          self.ex = TransactionServiceException()
20464 
          self.ex.read(iprot)
20465 
        else:
20466 
          iprot.skip(ftype)
20467 
      else:
20468 
        iprot.skip(ftype)
20469 
      iprot.readFieldEnd()
20470 
    iprot.readStructEnd()
20471 
 
20472 
  def write(self, oprot):
20473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20475 
      return
20476 
    oprot.writeStructBegin('savePaymentSettlements_result')
20477 
    if self.ex is not None:
20478 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20479 
      self.ex.write(oprot)
20480 
      oprot.writeFieldEnd()
20481 
    oprot.writeFieldStop()
20482 
    oprot.writeStructEnd()
20483 
 
20484 
  def validate(self):
20485 
    return
20486 
 
20487 
 
20488 
  def __repr__(self):
20489 
    L = ['%s=%r' % (key, value)
20490 
      for key, value in self.__dict__.iteritems()]
20491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20492 
 
20493 
  def __eq__(self, other):
20494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20495 
 
20496 
  def __ne__(self, other):
20497 
    return not (self == other)
20498 
 
20499 
class saveEBSSettlementSummary_args:
20500 
  """
20501 
  Attributes:
20502 
   - settlementId
20503 
   - settlementDate
20504 
   - transactionDateFrom
20505 
   - transactionDateTo
20506 
   - amount
20507 
  """
20508 
 
20509 
  thrift_spec = (
20510 
    None, # 0
20511 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20512 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
20513 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
20514 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
20515 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
20516 
  )
20517 
 
20518 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
20519 
    self.settlementId = settlementId
20520 
    self.settlementDate = settlementDate
20521 
    self.transactionDateFrom = transactionDateFrom
20522 
    self.transactionDateTo = transactionDateTo
20523 
    self.amount = amount
20524 
 
20525 
  def read(self, iprot):
20526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20528 
      return
20529 
    iprot.readStructBegin()
20530 
    while True:
20531 
      (fname, ftype, fid) = iprot.readFieldBegin()
20532 
      if ftype == TType.STOP:
20533 
        break
20534 
      if fid == 1:
20535 
        if ftype == TType.I64:
20536 
          self.settlementId = iprot.readI64();
20537 
        else:
20538 
          iprot.skip(ftype)
20539 
      elif fid == 2:
20540 
        if ftype == TType.I64:
20541 
          self.settlementDate = iprot.readI64();
20542 
        else:
20543 
          iprot.skip(ftype)
20544 
      elif fid == 3:
20545 
        if ftype == TType.I64:
20546 
          self.transactionDateFrom = iprot.readI64();
20547 
        else:
20548 
          iprot.skip(ftype)
20549 
      elif fid == 4:
20550 
        if ftype == TType.I64:
20551 
          self.transactionDateTo = iprot.readI64();
20552 
        else:
20553 
          iprot.skip(ftype)
20554 
      elif fid == 5:
20555 
        if ftype == TType.DOUBLE:
20556 
          self.amount = iprot.readDouble();
20557 
        else:
20558 
          iprot.skip(ftype)
20559 
      else:
20560 
        iprot.skip(ftype)
20561 
      iprot.readFieldEnd()
20562 
    iprot.readStructEnd()
20563 
 
20564 
  def write(self, oprot):
20565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20567 
      return
20568 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
20569 
    if self.settlementId is not None:
20570 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20571 
      oprot.writeI64(self.settlementId)
20572 
      oprot.writeFieldEnd()
20573 
    if self.settlementDate is not None:
20574 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
20575 
      oprot.writeI64(self.settlementDate)
20576 
      oprot.writeFieldEnd()
20577 
    if self.transactionDateFrom is not None:
20578 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
20579 
      oprot.writeI64(self.transactionDateFrom)
20580 
      oprot.writeFieldEnd()
20581 
    if self.transactionDateTo is not None:
20582 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
20583 
      oprot.writeI64(self.transactionDateTo)
20584 
      oprot.writeFieldEnd()
20585 
    if self.amount is not None:
20586 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
20587 
      oprot.writeDouble(self.amount)
20588 
      oprot.writeFieldEnd()
20589 
    oprot.writeFieldStop()
20590 
    oprot.writeStructEnd()
20591 
 
20592 
  def validate(self):
20593 
    return
20594 
 
20595 
 
20596 
  def __repr__(self):
20597 
    L = ['%s=%r' % (key, value)
20598 
      for key, value in self.__dict__.iteritems()]
20599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20600 
 
20601 
  def __eq__(self, other):
20602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20603 
 
20604 
  def __ne__(self, other):
20605 
    return not (self == other)
20606 
 
20607 
class saveEBSSettlementSummary_result:
20608 
  """
20609 
  Attributes:
20610 
   - ex
20611 
  """
20612 
 
20613 
  thrift_spec = (
20614 
    None, # 0
20615 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20616 
  )
20617 
 
20618 
  def __init__(self, ex=None,):
20619 
    self.ex = ex
20620 
 
20621 
  def read(self, iprot):
20622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20624 
      return
20625 
    iprot.readStructBegin()
20626 
    while True:
20627 
      (fname, ftype, fid) = iprot.readFieldBegin()
20628 
      if ftype == TType.STOP:
20629 
        break
20630 
      if fid == 1:
20631 
        if ftype == TType.STRUCT:
20632 
          self.ex = TransactionServiceException()
20633 
          self.ex.read(iprot)
20634 
        else:
20635 
          iprot.skip(ftype)
20636 
      else:
20637 
        iprot.skip(ftype)
20638 
      iprot.readFieldEnd()
20639 
    iprot.readStructEnd()
20640 
 
20641 
  def write(self, oprot):
20642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20644 
      return
20645 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
20646 
    if self.ex is not None:
20647 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20648 
      self.ex.write(oprot)
20649 
      oprot.writeFieldEnd()
20650 
    oprot.writeFieldStop()
20651 
    oprot.writeStructEnd()
20652 
 
20653 
  def validate(self):
20654 
    return
20655 
 
20656 
 
20657 
  def __repr__(self):
20658 
    L = ['%s=%r' % (key, value)
20659 
      for key, value in self.__dict__.iteritems()]
20660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20661 
 
20662 
  def __eq__(self, other):
20663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20664 
 
20665 
  def __ne__(self, other):
20666 
    return not (self == other)
20667 
 
5189 varun.gupt 20668 
class getSettlementForReferenceId_args:
4600 varun.gupt 20669 
  """
20670 
  Attributes:
5189 varun.gupt 20671 
   - referenceId
5382 varun.gupt 20672 
   - paymentGatewayId
5189 varun.gupt 20673 
   - isRefund
4600 varun.gupt 20674 
  """
20675 
 
20676 
  thrift_spec = (
20677 
    None, # 0
5189 varun.gupt 20678 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5382 varun.gupt 20679 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
20680 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
4600 varun.gupt 20681 
  )
20682 
 
5382 varun.gupt 20683 
  def __init__(self, referenceId=None, paymentGatewayId=None, isRefund=None,):
5189 varun.gupt 20684 
    self.referenceId = referenceId
5382 varun.gupt 20685 
    self.paymentGatewayId = paymentGatewayId
5189 varun.gupt 20686 
    self.isRefund = isRefund
4600 varun.gupt 20687 
 
20688 
  def read(self, iprot):
20689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20691 
      return
20692 
    iprot.readStructBegin()
20693 
    while True:
20694 
      (fname, ftype, fid) = iprot.readFieldBegin()
20695 
      if ftype == TType.STOP:
20696 
        break
20697 
      if fid == 1:
20698 
        if ftype == TType.I64:
5189 varun.gupt 20699 
          self.referenceId = iprot.readI64();
4600 varun.gupt 20700 
        else:
20701 
          iprot.skip(ftype)
5189 varun.gupt 20702 
      elif fid == 2:
5382 varun.gupt 20703 
        if ftype == TType.I64:
20704 
          self.paymentGatewayId = iprot.readI64();
20705 
        else:
20706 
          iprot.skip(ftype)
20707 
      elif fid == 3:
5189 varun.gupt 20708 
        if ftype == TType.BOOL:
20709 
          self.isRefund = iprot.readBool();
20710 
        else:
20711 
          iprot.skip(ftype)
4600 varun.gupt 20712 
      else:
20713 
        iprot.skip(ftype)
20714 
      iprot.readFieldEnd()
20715 
    iprot.readStructEnd()
20716 
 
20717 
  def write(self, oprot):
20718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20720 
      return
5189 varun.gupt 20721 
    oprot.writeStructBegin('getSettlementForReferenceId_args')
20722 
    if self.referenceId is not None:
20723 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
20724 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 20725 
      oprot.writeFieldEnd()
5382 varun.gupt 20726 
    if self.paymentGatewayId is not None:
20727 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
20728 
      oprot.writeI64(self.paymentGatewayId)
20729 
      oprot.writeFieldEnd()
5189 varun.gupt 20730 
    if self.isRefund is not None:
5382 varun.gupt 20731 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
5189 varun.gupt 20732 
      oprot.writeBool(self.isRefund)
20733 
      oprot.writeFieldEnd()
4600 varun.gupt 20734 
    oprot.writeFieldStop()
20735 
    oprot.writeStructEnd()
20736 
 
20737 
  def validate(self):
20738 
    return
20739 
 
20740 
 
20741 
  def __repr__(self):
20742 
    L = ['%s=%r' % (key, value)
20743 
      for key, value in self.__dict__.iteritems()]
20744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20745 
 
20746 
  def __eq__(self, other):
20747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20748 
 
20749 
  def __ne__(self, other):
20750 
    return not (self == other)
20751 
 
5189 varun.gupt 20752 
class getSettlementForReferenceId_result:
4600 varun.gupt 20753 
  """
20754 
  Attributes:
20755 
   - success
20756 
   - ex
20757 
  """
20758 
 
20759 
  thrift_spec = (
20760 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
20761 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20762 
  )
20763 
 
20764 
  def __init__(self, success=None, ex=None,):
20765 
    self.success = success
20766 
    self.ex = ex
20767 
 
20768 
  def read(self, iprot):
20769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20771 
      return
20772 
    iprot.readStructBegin()
20773 
    while True:
20774 
      (fname, ftype, fid) = iprot.readFieldBegin()
20775 
      if ftype == TType.STOP:
20776 
        break
20777 
      if fid == 0:
20778 
        if ftype == TType.STRUCT:
20779 
          self.success = PaymentSettlement()
20780 
          self.success.read(iprot)
20781 
        else:
20782 
          iprot.skip(ftype)
20783 
      elif fid == 1:
20784 
        if ftype == TType.STRUCT:
20785 
          self.ex = TransactionServiceException()
20786 
          self.ex.read(iprot)
20787 
        else:
20788 
          iprot.skip(ftype)
20789 
      else:
20790 
        iprot.skip(ftype)
20791 
      iprot.readFieldEnd()
20792 
    iprot.readStructEnd()
20793 
 
20794 
  def write(self, oprot):
20795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20797 
      return
5189 varun.gupt 20798 
    oprot.writeStructBegin('getSettlementForReferenceId_result')
4600 varun.gupt 20799 
    if self.success is not None:
20800 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20801 
      self.success.write(oprot)
20802 
      oprot.writeFieldEnd()
20803 
    if self.ex is not None:
20804 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20805 
      self.ex.write(oprot)
20806 
      oprot.writeFieldEnd()
20807 
    oprot.writeFieldStop()
20808 
    oprot.writeStructEnd()
20809 
 
20810 
  def validate(self):
20811 
    return
20812 
 
20813 
 
20814 
  def __repr__(self):
20815 
    L = ['%s=%r' % (key, value)
20816 
      for key, value in self.__dict__.iteritems()]
20817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20818 
 
20819 
  def __eq__(self, other):
20820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20821 
 
20822 
  def __ne__(self, other):
20823 
    return not (self == other)
20824 
 
20825 
class getEBSSettlementSummaries_args:
20826 
 
20827 
  thrift_spec = (
20828 
  )
20829 
 
20830 
  def read(self, iprot):
20831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20833 
      return
20834 
    iprot.readStructBegin()
20835 
    while True:
20836 
      (fname, ftype, fid) = iprot.readFieldBegin()
20837 
      if ftype == TType.STOP:
20838 
        break
20839 
      else:
20840 
        iprot.skip(ftype)
20841 
      iprot.readFieldEnd()
20842 
    iprot.readStructEnd()
20843 
 
20844 
  def write(self, oprot):
20845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20847 
      return
20848 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
20849 
    oprot.writeFieldStop()
20850 
    oprot.writeStructEnd()
20851 
 
20852 
  def validate(self):
20853 
    return
20854 
 
20855 
 
20856 
  def __repr__(self):
20857 
    L = ['%s=%r' % (key, value)
20858 
      for key, value in self.__dict__.iteritems()]
20859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20860 
 
20861 
  def __eq__(self, other):
20862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20863 
 
20864 
  def __ne__(self, other):
20865 
    return not (self == other)
20866 
 
20867 
class getEBSSettlementSummaries_result:
20868 
  """
20869 
  Attributes:
20870 
   - success
20871 
   - ex
20872 
  """
20873 
 
20874 
  thrift_spec = (
20875 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
20876 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20877 
  )
20878 
 
20879 
  def __init__(self, success=None, ex=None,):
20880 
    self.success = success
20881 
    self.ex = ex
20882 
 
20883 
  def read(self, iprot):
20884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20886 
      return
20887 
    iprot.readStructBegin()
20888 
    while True:
20889 
      (fname, ftype, fid) = iprot.readFieldBegin()
20890 
      if ftype == TType.STOP:
20891 
        break
20892 
      if fid == 0:
20893 
        if ftype == TType.MAP:
20894 
          self.success = {}
5031 varun.gupt 20895 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20896 
          for _i466 in xrange(_size462):
20897 
            _key467 = iprot.readI64();
20898 
            _val468 = iprot.readString();
20899 
            self.success[_key467] = _val468
4600 varun.gupt 20900 
          iprot.readMapEnd()
20901 
        else:
20902 
          iprot.skip(ftype)
20903 
      elif fid == 1:
20904 
        if ftype == TType.STRUCT:
20905 
          self.ex = TransactionServiceException()
20906 
          self.ex.read(iprot)
20907 
        else:
20908 
          iprot.skip(ftype)
20909 
      else:
20910 
        iprot.skip(ftype)
20911 
      iprot.readFieldEnd()
20912 
    iprot.readStructEnd()
20913 
 
20914 
  def write(self, oprot):
20915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20917 
      return
20918 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
20919 
    if self.success is not None:
20920 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20921 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
5031 varun.gupt 20922 
      for kiter469,viter470 in self.success.items():
20923 
        oprot.writeI64(kiter469)
20924 
        oprot.writeString(viter470)
4600 varun.gupt 20925 
      oprot.writeMapEnd()
20926 
      oprot.writeFieldEnd()
20927 
    if self.ex is not None:
20928 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20929 
      self.ex.write(oprot)
20930 
      oprot.writeFieldEnd()
20931 
    oprot.writeFieldStop()
20932 
    oprot.writeStructEnd()
20933 
 
20934 
  def validate(self):
20935 
    return
20936 
 
20937 
 
20938 
  def __repr__(self):
20939 
    L = ['%s=%r' % (key, value)
20940 
      for key, value in self.__dict__.iteritems()]
20941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20942 
 
20943 
  def __eq__(self, other):
20944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20945 
 
20946 
  def __ne__(self, other):
20947 
    return not (self == other)
20948 
 
20949 
class markEBSSettlementUploaded_args:
20950 
  """
20951 
  Attributes:
20952 
   - settlementId
20953 
  """
20954 
 
20955 
  thrift_spec = (
20956 
    None, # 0
20957 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20958 
  )
20959 
 
20960 
  def __init__(self, settlementId=None,):
20961 
    self.settlementId = settlementId
20962 
 
20963 
  def read(self, iprot):
20964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20966 
      return
20967 
    iprot.readStructBegin()
20968 
    while True:
20969 
      (fname, ftype, fid) = iprot.readFieldBegin()
20970 
      if ftype == TType.STOP:
20971 
        break
20972 
      if fid == 1:
20973 
        if ftype == TType.I64:
20974 
          self.settlementId = iprot.readI64();
20975 
        else:
20976 
          iprot.skip(ftype)
20977 
      else:
20978 
        iprot.skip(ftype)
20979 
      iprot.readFieldEnd()
20980 
    iprot.readStructEnd()
20981 
 
20982 
  def write(self, oprot):
20983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20985 
      return
20986 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
20987 
    if self.settlementId is not None:
20988 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20989 
      oprot.writeI64(self.settlementId)
20990 
      oprot.writeFieldEnd()
20991 
    oprot.writeFieldStop()
20992 
    oprot.writeStructEnd()
20993 
 
20994 
  def validate(self):
20995 
    return
20996 
 
20997 
 
20998 
  def __repr__(self):
20999 
    L = ['%s=%r' % (key, value)
21000 
      for key, value in self.__dict__.iteritems()]
21001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21002 
 
21003 
  def __eq__(self, other):
21004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21005 
 
21006 
  def __ne__(self, other):
21007 
    return not (self == other)
21008 
 
21009 
class markEBSSettlementUploaded_result:
21010 
  """
21011 
  Attributes:
21012 
   - ex
21013 
  """
21014 
 
21015 
  thrift_spec = (
21016 
    None, # 0
21017 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21018 
  )
21019 
 
21020 
  def __init__(self, ex=None,):
21021 
    self.ex = ex
21022 
 
21023 
  def read(self, iprot):
21024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21026 
      return
21027 
    iprot.readStructBegin()
21028 
    while True:
21029 
      (fname, ftype, fid) = iprot.readFieldBegin()
21030 
      if ftype == TType.STOP:
21031 
        break
21032 
      if fid == 1:
21033 
        if ftype == TType.STRUCT:
21034 
          self.ex = TransactionServiceException()
21035 
          self.ex.read(iprot)
21036 
        else:
21037 
          iprot.skip(ftype)
21038 
      else:
21039 
        iprot.skip(ftype)
21040 
      iprot.readFieldEnd()
21041 
    iprot.readStructEnd()
21042 
 
21043 
  def write(self, oprot):
21044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21046 
      return
21047 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
21048 
    if self.ex is not None:
21049 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21050 
      self.ex.write(oprot)
21051 
      oprot.writeFieldEnd()
21052 
    oprot.writeFieldStop()
21053 
    oprot.writeStructEnd()
21054 
 
21055 
  def validate(self):
21056 
    return
21057 
 
21058 
 
21059 
  def __repr__(self):
21060 
    L = ['%s=%r' % (key, value)
21061 
      for key, value in self.__dict__.iteritems()]
21062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21063 
 
21064 
  def __eq__(self, other):
21065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21066 
 
21067 
  def __ne__(self, other):
21068 
    return not (self == other)
21069 
 
21070 
class getEBSSettlementDate_args:
21071 
  """
21072 
  Attributes:
21073 
   - settlementId
21074 
  """
21075 
 
21076 
  thrift_spec = (
21077 
    None, # 0
21078 
    (1, TType.I64, 'settlementId', None, None, ), # 1
21079 
  )
21080 
 
21081 
  def __init__(self, settlementId=None,):
21082 
    self.settlementId = settlementId
21083 
 
21084 
  def read(self, iprot):
21085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21087 
      return
21088 
    iprot.readStructBegin()
21089 
    while True:
21090 
      (fname, ftype, fid) = iprot.readFieldBegin()
21091 
      if ftype == TType.STOP:
21092 
        break
21093 
      if fid == 1:
21094 
        if ftype == TType.I64:
21095 
          self.settlementId = iprot.readI64();
21096 
        else:
21097 
          iprot.skip(ftype)
21098 
      else:
21099 
        iprot.skip(ftype)
21100 
      iprot.readFieldEnd()
21101 
    iprot.readStructEnd()
21102 
 
21103 
  def write(self, oprot):
21104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21106 
      return
21107 
    oprot.writeStructBegin('getEBSSettlementDate_args')
21108 
    if self.settlementId is not None:
21109 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
21110 
      oprot.writeI64(self.settlementId)
21111 
      oprot.writeFieldEnd()
21112 
    oprot.writeFieldStop()
21113 
    oprot.writeStructEnd()
21114 
 
21115 
  def validate(self):
21116 
    return
21117 
 
21118 
 
21119 
  def __repr__(self):
21120 
    L = ['%s=%r' % (key, value)
21121 
      for key, value in self.__dict__.iteritems()]
21122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21123 
 
21124 
  def __eq__(self, other):
21125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21126 
 
21127 
  def __ne__(self, other):
21128 
    return not (self == other)
21129 
 
21130 
class getEBSSettlementDate_result:
21131 
  """
21132 
  Attributes:
21133 
   - success
21134 
   - ex
21135 
  """
21136 
 
21137 
  thrift_spec = (
21138 
    (0, TType.I64, 'success', None, None, ), # 0
21139 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21140 
  )
21141 
 
21142 
  def __init__(self, success=None, ex=None,):
21143 
    self.success = success
21144 
    self.ex = ex
21145 
 
21146 
  def read(self, iprot):
21147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21149 
      return
21150 
    iprot.readStructBegin()
21151 
    while True:
21152 
      (fname, ftype, fid) = iprot.readFieldBegin()
21153 
      if ftype == TType.STOP:
21154 
        break
21155 
      if fid == 0:
21156 
        if ftype == TType.I64:
21157 
          self.success = iprot.readI64();
21158 
        else:
21159 
          iprot.skip(ftype)
21160 
      elif fid == 1:
21161 
        if ftype == TType.STRUCT:
21162 
          self.ex = TransactionServiceException()
21163 
          self.ex.read(iprot)
21164 
        else:
21165 
          iprot.skip(ftype)
21166 
      else:
21167 
        iprot.skip(ftype)
21168 
      iprot.readFieldEnd()
21169 
    iprot.readStructEnd()
21170 
 
21171 
  def write(self, oprot):
21172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21174 
      return
21175 
    oprot.writeStructBegin('getEBSSettlementDate_result')
21176 
    if self.success is not None:
21177 
      oprot.writeFieldBegin('success', TType.I64, 0)
21178 
      oprot.writeI64(self.success)
21179 
      oprot.writeFieldEnd()
21180 
    if self.ex is not None:
21181 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21182 
      self.ex.write(oprot)
21183 
      oprot.writeFieldEnd()
21184 
    oprot.writeFieldStop()
21185 
    oprot.writeStructEnd()
21186 
 
21187 
  def validate(self):
21188 
    return
21189 
 
21190 
 
21191 
  def __repr__(self):
21192 
    L = ['%s=%r' % (key, value)
21193 
      for key, value in self.__dict__.iteritems()]
21194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21195 
 
21196 
  def __eq__(self, other):
21197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21198 
 
21199 
  def __ne__(self, other):
21200 
    return not (self == other)
4715 varun.gupt 21201 
 
21202 
class getSettlementsByDate_args:
21203 
  """
21204 
  Attributes:
21205 
   - settlementDateFrom
21206 
   - settlementDateTo
21207 
   - isRefund
21208 
  """
21209 
 
21210 
  thrift_spec = (
21211 
    None, # 0
21212 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
21213 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
21214 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
21215 
  )
21216 
 
21217 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
21218 
    self.settlementDateFrom = settlementDateFrom
21219 
    self.settlementDateTo = settlementDateTo
21220 
    self.isRefund = isRefund
21221 
 
21222 
  def read(self, iprot):
21223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21225 
      return
21226 
    iprot.readStructBegin()
21227 
    while True:
21228 
      (fname, ftype, fid) = iprot.readFieldBegin()
21229 
      if ftype == TType.STOP:
21230 
        break
21231 
      if fid == 1:
21232 
        if ftype == TType.I64:
21233 
          self.settlementDateFrom = iprot.readI64();
21234 
        else:
21235 
          iprot.skip(ftype)
21236 
      elif fid == 2:
21237 
        if ftype == TType.I64:
21238 
          self.settlementDateTo = iprot.readI64();
21239 
        else:
21240 
          iprot.skip(ftype)
21241 
      elif fid == 3:
21242 
        if ftype == TType.BOOL:
21243 
          self.isRefund = iprot.readBool();
21244 
        else:
21245 
          iprot.skip(ftype)
21246 
      else:
21247 
        iprot.skip(ftype)
21248 
      iprot.readFieldEnd()
21249 
    iprot.readStructEnd()
21250 
 
21251 
  def write(self, oprot):
21252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21254 
      return
21255 
    oprot.writeStructBegin('getSettlementsByDate_args')
21256 
    if self.settlementDateFrom is not None:
21257 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
21258 
      oprot.writeI64(self.settlementDateFrom)
21259 
      oprot.writeFieldEnd()
21260 
    if self.settlementDateTo is not None:
21261 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
21262 
      oprot.writeI64(self.settlementDateTo)
21263 
      oprot.writeFieldEnd()
21264 
    if self.isRefund is not None:
21265 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
21266 
      oprot.writeBool(self.isRefund)
21267 
      oprot.writeFieldEnd()
21268 
    oprot.writeFieldStop()
21269 
    oprot.writeStructEnd()
21270 
 
21271 
  def validate(self):
21272 
    return
21273 
 
21274 
 
21275 
  def __repr__(self):
21276 
    L = ['%s=%r' % (key, value)
21277 
      for key, value in self.__dict__.iteritems()]
21278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21279 
 
21280 
  def __eq__(self, other):
21281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21282 
 
21283 
  def __ne__(self, other):
21284 
    return not (self == other)
21285 
 
21286 
class getSettlementsByDate_result:
21287 
  """
21288 
  Attributes:
21289 
   - success
21290 
   - ex
21291 
  """
21292 
 
21293 
  thrift_spec = (
21294 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
21295 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21296 
  )
21297 
 
21298 
  def __init__(self, success=None, ex=None,):
21299 
    self.success = success
21300 
    self.ex = ex
21301 
 
21302 
  def read(self, iprot):
21303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21305 
      return
21306 
    iprot.readStructBegin()
21307 
    while True:
21308 
      (fname, ftype, fid) = iprot.readFieldBegin()
21309 
      if ftype == TType.STOP:
21310 
        break
21311 
      if fid == 0:
21312 
        if ftype == TType.LIST:
21313 
          self.success = []
5031 varun.gupt 21314 
          (_etype474, _size471) = iprot.readListBegin()
21315 
          for _i475 in xrange(_size471):
21316 
            _elem476 = PaymentSettlement()
21317 
            _elem476.read(iprot)
21318 
            self.success.append(_elem476)
4715 varun.gupt 21319 
          iprot.readListEnd()
21320 
        else:
21321 
          iprot.skip(ftype)
21322 
      elif fid == 1:
21323 
        if ftype == TType.STRUCT:
21324 
          self.ex = TransactionServiceException()
21325 
          self.ex.read(iprot)
21326 
        else:
21327 
          iprot.skip(ftype)
21328 
      else:
21329 
        iprot.skip(ftype)
21330 
      iprot.readFieldEnd()
21331 
    iprot.readStructEnd()
21332 
 
21333 
  def write(self, oprot):
21334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21336 
      return
21337 
    oprot.writeStructBegin('getSettlementsByDate_result')
21338 
    if self.success is not None:
21339 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21340 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 21341 
      for iter477 in self.success:
21342 
        iter477.write(oprot)
4715 varun.gupt 21343 
      oprot.writeListEnd()
21344 
      oprot.writeFieldEnd()
21345 
    if self.ex is not None:
21346 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21347 
      self.ex.write(oprot)
21348 
      oprot.writeFieldEnd()
21349 
    oprot.writeFieldStop()
21350 
    oprot.writeStructEnd()
21351 
 
21352 
  def validate(self):
21353 
    return
21354 
 
21355 
 
21356 
  def __repr__(self):
21357 
    L = ['%s=%r' % (key, value)
21358 
      for key, value in self.__dict__.iteritems()]
21359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21360 
 
21361 
  def __eq__(self, other):
21362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21363 
 
21364 
  def __ne__(self, other):
21365 
    return not (self == other)
21366 
 
21367 
class getReshippedOrderIds_args:
21368 
  """
21369 
  Attributes:
21370 
   - orderIds
21371 
  """
21372 
 
21373 
  thrift_spec = (
21374 
    None, # 0
21375 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
21376 
  )
21377 
 
21378 
  def __init__(self, orderIds=None,):
21379 
    self.orderIds = orderIds
21380 
 
21381 
  def read(self, iprot):
21382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21384 
      return
21385 
    iprot.readStructBegin()
21386 
    while True:
21387 
      (fname, ftype, fid) = iprot.readFieldBegin()
21388 
      if ftype == TType.STOP:
21389 
        break
21390 
      if fid == 1:
21391 
        if ftype == TType.LIST:
21392 
          self.orderIds = []
5031 varun.gupt 21393 
          (_etype481, _size478) = iprot.readListBegin()
21394 
          for _i482 in xrange(_size478):
21395 
            _elem483 = iprot.readI64();
21396 
            self.orderIds.append(_elem483)
4715 varun.gupt 21397 
          iprot.readListEnd()
21398 
        else:
21399 
          iprot.skip(ftype)
21400 
      else:
21401 
        iprot.skip(ftype)
21402 
      iprot.readFieldEnd()
21403 
    iprot.readStructEnd()
21404 
 
21405 
  def write(self, oprot):
21406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21408 
      return
21409 
    oprot.writeStructBegin('getReshippedOrderIds_args')
21410 
    if self.orderIds is not None:
21411 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
21412 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5031 varun.gupt 21413 
      for iter484 in self.orderIds:
21414 
        oprot.writeI64(iter484)
4715 varun.gupt 21415 
      oprot.writeListEnd()
21416 
      oprot.writeFieldEnd()
21417 
    oprot.writeFieldStop()
21418 
    oprot.writeStructEnd()
21419 
 
21420 
  def validate(self):
21421 
    return
21422 
 
21423 
 
21424 
  def __repr__(self):
21425 
    L = ['%s=%r' % (key, value)
21426 
      for key, value in self.__dict__.iteritems()]
21427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21428 
 
21429 
  def __eq__(self, other):
21430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21431 
 
21432 
  def __ne__(self, other):
21433 
    return not (self == other)
21434 
 
21435 
class getReshippedOrderIds_result:
21436 
  """
21437 
  Attributes:
21438 
   - success
21439 
   - ex
21440 
  """
21441 
 
21442 
  thrift_spec = (
21443 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21444 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21445 
  )
21446 
 
21447 
  def __init__(self, success=None, ex=None,):
21448 
    self.success = success
21449 
    self.ex = ex
21450 
 
21451 
  def read(self, iprot):
21452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21454 
      return
21455 
    iprot.readStructBegin()
21456 
    while True:
21457 
      (fname, ftype, fid) = iprot.readFieldBegin()
21458 
      if ftype == TType.STOP:
21459 
        break
21460 
      if fid == 0:
21461 
        if ftype == TType.LIST:
21462 
          self.success = []
5031 varun.gupt 21463 
          (_etype488, _size485) = iprot.readListBegin()
21464 
          for _i489 in xrange(_size485):
21465 
            _elem490 = iprot.readI64();
21466 
            self.success.append(_elem490)
4715 varun.gupt 21467 
          iprot.readListEnd()
21468 
        else:
21469 
          iprot.skip(ftype)
21470 
      elif fid == 1:
21471 
        if ftype == TType.STRUCT:
21472 
          self.ex = TransactionServiceException()
21473 
          self.ex.read(iprot)
21474 
        else:
21475 
          iprot.skip(ftype)
21476 
      else:
21477 
        iprot.skip(ftype)
21478 
      iprot.readFieldEnd()
21479 
    iprot.readStructEnd()
21480 
 
21481 
  def write(self, oprot):
21482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21484 
      return
21485 
    oprot.writeStructBegin('getReshippedOrderIds_result')
21486 
    if self.success is not None:
21487 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21488 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 21489 
      for iter491 in self.success:
21490 
        oprot.writeI64(iter491)
4715 varun.gupt 21491 
      oprot.writeListEnd()
21492 
      oprot.writeFieldEnd()
21493 
    if self.ex is not None:
21494 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21495 
      self.ex.write(oprot)
21496 
      oprot.writeFieldEnd()
21497 
    oprot.writeFieldStop()
21498 
    oprot.writeStructEnd()
21499 
 
21500 
  def validate(self):
21501 
    return
21502 
 
21503 
 
21504 
  def __repr__(self):
21505 
    L = ['%s=%r' % (key, value)
21506 
      for key, value in self.__dict__.iteritems()]
21507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21508 
 
21509 
  def __eq__(self, other):
21510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21511 
 
21512 
  def __ne__(self, other):
21513 
    return not (self == other)
4757 mandeep.dh 21514 
 
5348 anupam.sin 21515 
class updateOrdersAsPORaised_args:
21516 
  """
21517 
  Attributes:
21518 
   - itemIdQuantityMap
21519 
   - purchaseOrderId
21520 
   - warehouseId
21521 
  """
21522 
 
21523 
  thrift_spec = (
21524 
    None, # 0
21525 
    (1, TType.MAP, 'itemIdQuantityMap', (TType.I64,None,TType.I64,None), None, ), # 1
21526 
    (2, TType.I64, 'purchaseOrderId', None, None, ), # 2
21527 
    (3, TType.I64, 'warehouseId', None, None, ), # 3
21528 
  )
21529 
 
21530 
  def __init__(self, itemIdQuantityMap=None, purchaseOrderId=None, warehouseId=None,):
21531 
    self.itemIdQuantityMap = itemIdQuantityMap
21532 
    self.purchaseOrderId = purchaseOrderId
21533 
    self.warehouseId = warehouseId
21534 
 
21535 
  def read(self, iprot):
21536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21538 
      return
21539 
    iprot.readStructBegin()
21540 
    while True:
21541 
      (fname, ftype, fid) = iprot.readFieldBegin()
21542 
      if ftype == TType.STOP:
21543 
        break
21544 
      if fid == 1:
21545 
        if ftype == TType.MAP:
21546 
          self.itemIdQuantityMap = {}
21547 
          (_ktype493, _vtype494, _size492 ) = iprot.readMapBegin()
21548 
          for _i496 in xrange(_size492):
21549 
            _key497 = iprot.readI64();
21550 
            _val498 = iprot.readI64();
21551 
            self.itemIdQuantityMap[_key497] = _val498
21552 
          iprot.readMapEnd()
21553 
        else:
21554 
          iprot.skip(ftype)
21555 
      elif fid == 2:
21556 
        if ftype == TType.I64:
21557 
          self.purchaseOrderId = iprot.readI64();
21558 
        else:
21559 
          iprot.skip(ftype)
21560 
      elif fid == 3:
21561 
        if ftype == TType.I64:
21562 
          self.warehouseId = iprot.readI64();
21563 
        else:
21564 
          iprot.skip(ftype)
21565 
      else:
21566 
        iprot.skip(ftype)
21567 
      iprot.readFieldEnd()
21568 
    iprot.readStructEnd()
21569 
 
21570 
  def write(self, oprot):
21571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21573 
      return
21574 
    oprot.writeStructBegin('updateOrdersAsPORaised_args')
21575 
    if self.itemIdQuantityMap is not None:
21576 
      oprot.writeFieldBegin('itemIdQuantityMap', TType.MAP, 1)
21577 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemIdQuantityMap))
21578 
      for kiter499,viter500 in self.itemIdQuantityMap.items():
21579 
        oprot.writeI64(kiter499)
21580 
        oprot.writeI64(viter500)
21581 
      oprot.writeMapEnd()
21582 
      oprot.writeFieldEnd()
21583 
    if self.purchaseOrderId is not None:
21584 
      oprot.writeFieldBegin('purchaseOrderId', TType.I64, 2)
21585 
      oprot.writeI64(self.purchaseOrderId)
21586 
      oprot.writeFieldEnd()
21587 
    if self.warehouseId is not None:
21588 
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
21589 
      oprot.writeI64(self.warehouseId)
21590 
      oprot.writeFieldEnd()
21591 
    oprot.writeFieldStop()
21592 
    oprot.writeStructEnd()
21593 
 
21594 
  def validate(self):
21595 
    return
21596 
 
21597 
 
21598 
  def __repr__(self):
21599 
    L = ['%s=%r' % (key, value)
21600 
      for key, value in self.__dict__.iteritems()]
21601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21602 
 
21603 
  def __eq__(self, other):
21604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21605 
 
21606 
  def __ne__(self, other):
21607 
    return not (self == other)
21608 
 
21609 
class updateOrdersAsPORaised_result:
21610 
  """
21611 
  Attributes:
21612 
   - ex
21613 
  """
21614 
 
21615 
  thrift_spec = (
21616 
    None, # 0
21617 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21618 
  )
21619 
 
21620 
  def __init__(self, ex=None,):
21621 
    self.ex = ex
21622 
 
21623 
  def read(self, iprot):
21624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21626 
      return
21627 
    iprot.readStructBegin()
21628 
    while True:
21629 
      (fname, ftype, fid) = iprot.readFieldBegin()
21630 
      if ftype == TType.STOP:
21631 
        break
21632 
      if fid == 1:
21633 
        if ftype == TType.STRUCT:
21634 
          self.ex = TransactionServiceException()
21635 
          self.ex.read(iprot)
21636 
        else:
21637 
          iprot.skip(ftype)
21638 
      else:
21639 
        iprot.skip(ftype)
21640 
      iprot.readFieldEnd()
21641 
    iprot.readStructEnd()
21642 
 
21643 
  def write(self, oprot):
21644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21646 
      return
21647 
    oprot.writeStructBegin('updateOrdersAsPORaised_result')
21648 
    if self.ex is not None:
21649 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21650 
      self.ex.write(oprot)
21651 
      oprot.writeFieldEnd()
21652 
    oprot.writeFieldStop()
21653 
    oprot.writeStructEnd()
21654 
 
21655 
  def validate(self):
21656 
    return
21657 
 
21658 
 
21659 
  def __repr__(self):
21660 
    L = ['%s=%r' % (key, value)
21661 
      for key, value in self.__dict__.iteritems()]
21662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21663 
 
21664 
  def __eq__(self, other):
21665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21666 
 
21667 
  def __ne__(self, other):
21668 
    return not (self == other)
21669 
 
4875 varun.gupt 21670 
class getOrdersWhereVendorNotPaid_args:
21671 
  """
21672 
  Attributes:
21673 
   - vendorId
21674 
  """
21675 
 
21676 
  thrift_spec = (
21677 
    None, # 0
21678 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21679 
  )
21680 
 
21681 
  def __init__(self, vendorId=None,):
21682 
    self.vendorId = vendorId
21683 
 
21684 
  def read(self, iprot):
21685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21687 
      return
21688 
    iprot.readStructBegin()
21689 
    while True:
21690 
      (fname, ftype, fid) = iprot.readFieldBegin()
21691 
      if ftype == TType.STOP:
21692 
        break
21693 
      if fid == 1:
21694 
        if ftype == TType.I64:
21695 
          self.vendorId = iprot.readI64();
21696 
        else:
21697 
          iprot.skip(ftype)
21698 
      else:
21699 
        iprot.skip(ftype)
21700 
      iprot.readFieldEnd()
21701 
    iprot.readStructEnd()
21702 
 
21703 
  def write(self, oprot):
21704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21706 
      return
21707 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_args')
21708 
    if self.vendorId is not None:
21709 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21710 
      oprot.writeI64(self.vendorId)
21711 
      oprot.writeFieldEnd()
21712 
    oprot.writeFieldStop()
21713 
    oprot.writeStructEnd()
21714 
 
21715 
  def validate(self):
21716 
    return
21717 
 
21718 
 
21719 
  def __repr__(self):
21720 
    L = ['%s=%r' % (key, value)
21721 
      for key, value in self.__dict__.iteritems()]
21722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21723 
 
21724 
  def __eq__(self, other):
21725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21726 
 
21727 
  def __ne__(self, other):
21728 
    return not (self == other)
21729 
 
21730 
class getOrdersWhereVendorNotPaid_result:
21731 
  """
21732 
  Attributes:
21733 
   - success
21734 
   - ex
21735 
  """
21736 
 
21737 
  thrift_spec = (
21738 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21739 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21740 
  )
21741 
 
21742 
  def __init__(self, success=None, ex=None,):
21743 
    self.success = success
21744 
    self.ex = ex
21745 
 
21746 
  def read(self, iprot):
21747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21749 
      return
21750 
    iprot.readStructBegin()
21751 
    while True:
21752 
      (fname, ftype, fid) = iprot.readFieldBegin()
21753 
      if ftype == TType.STOP:
21754 
        break
21755 
      if fid == 0:
21756 
        if ftype == TType.LIST:
21757 
          self.success = []
5348 anupam.sin 21758 
          (_etype504, _size501) = iprot.readListBegin()
21759 
          for _i505 in xrange(_size501):
21760 
            _elem506 = Order()
21761 
            _elem506.read(iprot)
21762 
            self.success.append(_elem506)
4875 varun.gupt 21763 
          iprot.readListEnd()
21764 
        else:
21765 
          iprot.skip(ftype)
21766 
      elif fid == 1:
21767 
        if ftype == TType.STRUCT:
21768 
          self.ex = TransactionServiceException()
21769 
          self.ex.read(iprot)
21770 
        else:
21771 
          iprot.skip(ftype)
21772 
      else:
21773 
        iprot.skip(ftype)
21774 
      iprot.readFieldEnd()
21775 
    iprot.readStructEnd()
21776 
 
21777 
  def write(self, oprot):
21778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21780 
      return
21781 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_result')
21782 
    if self.success is not None:
21783 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21784 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5348 anupam.sin 21785 
      for iter507 in self.success:
21786 
        iter507.write(oprot)
4875 varun.gupt 21787 
      oprot.writeListEnd()
21788 
      oprot.writeFieldEnd()
21789 
    if self.ex is not None:
21790 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21791 
      self.ex.write(oprot)
21792 
      oprot.writeFieldEnd()
21793 
    oprot.writeFieldStop()
21794 
    oprot.writeStructEnd()
21795 
 
21796 
  def validate(self):
21797 
    return
21798 
 
21799 
 
21800 
  def __repr__(self):
21801 
    L = ['%s=%r' % (key, value)
21802 
      for key, value in self.__dict__.iteritems()]
21803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21804 
 
21805 
  def __eq__(self, other):
21806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21807 
 
21808 
  def __ne__(self, other):
21809 
    return not (self == other)
5031 varun.gupt 21810 
 
21811 
class getStatusDistributionOfOrders_args:
21812 
  """
21813 
  Attributes:
21814 
   - startDate
21815 
   - endDate
21816 
  """
21817 
 
21818 
  thrift_spec = (
21819 
    None, # 0
21820 
    (1, TType.I64, 'startDate', None, None, ), # 1
21821 
    (2, TType.I64, 'endDate', None, None, ), # 2
21822 
  )
21823 
 
21824 
  def __init__(self, startDate=None, endDate=None,):
21825 
    self.startDate = startDate
21826 
    self.endDate = endDate
21827 
 
21828 
  def read(self, iprot):
21829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21831 
      return
21832 
    iprot.readStructBegin()
21833 
    while True:
21834 
      (fname, ftype, fid) = iprot.readFieldBegin()
21835 
      if ftype == TType.STOP:
21836 
        break
21837 
      if fid == 1:
21838 
        if ftype == TType.I64:
21839 
          self.startDate = iprot.readI64();
21840 
        else:
21841 
          iprot.skip(ftype)
21842 
      elif fid == 2:
21843 
        if ftype == TType.I64:
21844 
          self.endDate = iprot.readI64();
21845 
        else:
21846 
          iprot.skip(ftype)
21847 
      else:
21848 
        iprot.skip(ftype)
21849 
      iprot.readFieldEnd()
21850 
    iprot.readStructEnd()
21851 
 
21852 
  def write(self, oprot):
21853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21855 
      return
21856 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
21857 
    if self.startDate is not None:
21858 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
21859 
      oprot.writeI64(self.startDate)
21860 
      oprot.writeFieldEnd()
21861 
    if self.endDate is not None:
21862 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
21863 
      oprot.writeI64(self.endDate)
21864 
      oprot.writeFieldEnd()
21865 
    oprot.writeFieldStop()
21866 
    oprot.writeStructEnd()
21867 
 
21868 
  def validate(self):
21869 
    return
21870 
 
21871 
 
21872 
  def __repr__(self):
21873 
    L = ['%s=%r' % (key, value)
21874 
      for key, value in self.__dict__.iteritems()]
21875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21876 
 
21877 
  def __eq__(self, other):
21878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21879 
 
21880 
  def __ne__(self, other):
21881 
    return not (self == other)
21882 
 
21883 
class getStatusDistributionOfOrders_result:
21884 
  """
21885 
  Attributes:
21886 
   - success
21887 
   - ex
21888 
  """
21889 
 
21890 
  thrift_spec = (
21891 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
21892 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21893 
  )
21894 
 
21895 
  def __init__(self, success=None, ex=None,):
21896 
    self.success = success
21897 
    self.ex = ex
21898 
 
21899 
  def read(self, iprot):
21900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21902 
      return
21903 
    iprot.readStructBegin()
21904 
    while True:
21905 
      (fname, ftype, fid) = iprot.readFieldBegin()
21906 
      if ftype == TType.STOP:
21907 
        break
21908 
      if fid == 0:
21909 
        if ftype == TType.MAP:
21910 
          self.success = {}
5348 anupam.sin 21911 
          (_ktype509, _vtype510, _size508 ) = iprot.readMapBegin()
21912 
          for _i512 in xrange(_size508):
21913 
            _key513 = iprot.readI64();
21914 
            _val514 = iprot.readI64();
21915 
            self.success[_key513] = _val514
5031 varun.gupt 21916 
          iprot.readMapEnd()
21917 
        else:
21918 
          iprot.skip(ftype)
21919 
      elif fid == 1:
21920 
        if ftype == TType.STRUCT:
21921 
          self.ex = TransactionServiceException()
21922 
          self.ex.read(iprot)
21923 
        else:
21924 
          iprot.skip(ftype)
21925 
      else:
21926 
        iprot.skip(ftype)
21927 
      iprot.readFieldEnd()
21928 
    iprot.readStructEnd()
21929 
 
21930 
  def write(self, oprot):
21931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21933 
      return
21934 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
21935 
    if self.success is not None:
21936 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21937 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5348 anupam.sin 21938 
      for kiter515,viter516 in self.success.items():
21939 
        oprot.writeI64(kiter515)
21940 
        oprot.writeI64(viter516)
5031 varun.gupt 21941 
      oprot.writeMapEnd()
21942 
      oprot.writeFieldEnd()
21943 
    if self.ex is not None:
21944 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21945 
      self.ex.write(oprot)
21946 
      oprot.writeFieldEnd()
21947 
    oprot.writeFieldStop()
21948 
    oprot.writeStructEnd()
21949 
 
21950 
  def validate(self):
21951 
    return
21952 
 
21953 
 
21954 
  def __repr__(self):
21955 
    L = ['%s=%r' % (key, value)
21956 
      for key, value in self.__dict__.iteritems()]
21957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21958 
 
21959 
  def __eq__(self, other):
21960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21961 
 
21962 
  def __ne__(self, other):
21963 
    return not (self == other)
5067 varun.gupt 21964 
 
21965 
class getOrderIdsForStatus_args:
21966 
  """
21967 
  Attributes:
21968 
   - status
21969 
   - startDatetime
21970 
   - endDatetime
21971 
  """
21972 
 
21973 
  thrift_spec = (
21974 
    None, # 0
21975 
    (1, TType.I64, 'status', None, None, ), # 1
21976 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
21977 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
21978 
  )
21979 
 
21980 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
21981 
    self.status = status
21982 
    self.startDatetime = startDatetime
21983 
    self.endDatetime = endDatetime
21984 
 
21985 
  def read(self, iprot):
21986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21988 
      return
21989 
    iprot.readStructBegin()
21990 
    while True:
21991 
      (fname, ftype, fid) = iprot.readFieldBegin()
21992 
      if ftype == TType.STOP:
21993 
        break
21994 
      if fid == 1:
21995 
        if ftype == TType.I64:
21996 
          self.status = iprot.readI64();
21997 
        else:
21998 
          iprot.skip(ftype)
21999 
      elif fid == 2:
22000 
        if ftype == TType.I64:
22001 
          self.startDatetime = iprot.readI64();
22002 
        else:
22003 
          iprot.skip(ftype)
22004 
      elif fid == 3:
22005 
        if ftype == TType.I64:
22006 
          self.endDatetime = iprot.readI64();
22007 
        else:
22008 
          iprot.skip(ftype)
22009 
      else:
22010 
        iprot.skip(ftype)
22011 
      iprot.readFieldEnd()
22012 
    iprot.readStructEnd()
22013 
 
22014 
  def write(self, oprot):
22015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22017 
      return
22018 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
22019 
    if self.status is not None:
22020 
      oprot.writeFieldBegin('status', TType.I64, 1)
22021 
      oprot.writeI64(self.status)
22022 
      oprot.writeFieldEnd()
22023 
    if self.startDatetime is not None:
22024 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
22025 
      oprot.writeI64(self.startDatetime)
22026 
      oprot.writeFieldEnd()
22027 
    if self.endDatetime is not None:
22028 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
22029 
      oprot.writeI64(self.endDatetime)
22030 
      oprot.writeFieldEnd()
22031 
    oprot.writeFieldStop()
22032 
    oprot.writeStructEnd()
22033 
 
22034 
  def validate(self):
22035 
    return
22036 
 
22037 
 
22038 
  def __repr__(self):
22039 
    L = ['%s=%r' % (key, value)
22040 
      for key, value in self.__dict__.iteritems()]
22041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22042 
 
22043 
  def __eq__(self, other):
22044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22045 
 
22046 
  def __ne__(self, other):
22047 
    return not (self == other)
22048 
 
22049 
class getOrderIdsForStatus_result:
22050 
  """
22051 
  Attributes:
22052 
   - success
22053 
   - ex
22054 
  """
22055 
 
22056 
  thrift_spec = (
22057 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
22058 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22059 
  )
22060 
 
22061 
  def __init__(self, success=None, ex=None,):
22062 
    self.success = success
22063 
    self.ex = ex
22064 
 
22065 
  def read(self, iprot):
22066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22068 
      return
22069 
    iprot.readStructBegin()
22070 
    while True:
22071 
      (fname, ftype, fid) = iprot.readFieldBegin()
22072 
      if ftype == TType.STOP:
22073 
        break
22074 
      if fid == 0:
22075 
        if ftype == TType.LIST:
22076 
          self.success = []
5348 anupam.sin 22077 
          (_etype520, _size517) = iprot.readListBegin()
22078 
          for _i521 in xrange(_size517):
22079 
            _elem522 = iprot.readI64();
22080 
            self.success.append(_elem522)
5067 varun.gupt 22081 
          iprot.readListEnd()
22082 
        else:
22083 
          iprot.skip(ftype)
22084 
      elif fid == 1:
22085 
        if ftype == TType.STRUCT:
22086 
          self.ex = TransactionServiceException()
22087 
          self.ex.read(iprot)
22088 
        else:
22089 
          iprot.skip(ftype)
22090 
      else:
22091 
        iprot.skip(ftype)
22092 
      iprot.readFieldEnd()
22093 
    iprot.readStructEnd()
22094 
 
22095 
  def write(self, oprot):
22096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22098 
      return
22099 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
22100 
    if self.success is not None:
22101 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22102 
      oprot.writeListBegin(TType.I64, len(self.success))
5348 anupam.sin 22103 
      for iter523 in self.success:
22104 
        oprot.writeI64(iter523)
5067 varun.gupt 22105 
      oprot.writeListEnd()
22106 
      oprot.writeFieldEnd()
22107 
    if self.ex is not None:
22108 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22109 
      self.ex.write(oprot)
22110 
      oprot.writeFieldEnd()
22111 
    oprot.writeFieldStop()
22112 
    oprot.writeStructEnd()
22113 
 
22114 
  def validate(self):
22115 
    return
22116 
 
22117 
 
22118 
  def __repr__(self):
22119 
    L = ['%s=%r' % (key, value)
22120 
      for key, value in self.__dict__.iteritems()]
22121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22122 
 
22123 
  def __eq__(self, other):
22124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22125 
 
22126 
  def __ne__(self, other):
22127 
    return not (self == other)
5099 varun.gupt 22128 
 
5348 anupam.sin 22129 
class updateCODAgent_args:
22130 
  """
22131 
  Attributes:
22132 
   - agent
22133 
   - orderId
22134 
  """
22135 
 
22136 
  thrift_spec = (
22137 
    None, # 0
22138 
    (1, TType.STRING, 'agent', None, None, ), # 1
22139 
    (2, TType.I64, 'orderId', None, None, ), # 2
22140 
  )
22141 
 
22142 
  def __init__(self, agent=None, orderId=None,):
22143 
    self.agent = agent
22144 
    self.orderId = orderId
22145 
 
22146 
  def read(self, iprot):
22147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22149 
      return
22150 
    iprot.readStructBegin()
22151 
    while True:
22152 
      (fname, ftype, fid) = iprot.readFieldBegin()
22153 
      if ftype == TType.STOP:
22154 
        break
22155 
      if fid == 1:
22156 
        if ftype == TType.STRING:
22157 
          self.agent = iprot.readString();
22158 
        else:
22159 
          iprot.skip(ftype)
22160 
      elif fid == 2:
22161 
        if ftype == TType.I64:
22162 
          self.orderId = iprot.readI64();
22163 
        else:
22164 
          iprot.skip(ftype)
22165 
      else:
22166 
        iprot.skip(ftype)
22167 
      iprot.readFieldEnd()
22168 
    iprot.readStructEnd()
22169 
 
22170 
  def write(self, oprot):
22171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22173 
      return
22174 
    oprot.writeStructBegin('updateCODAgent_args')
22175 
    if self.agent is not None:
22176 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
22177 
      oprot.writeString(self.agent)
22178 
      oprot.writeFieldEnd()
22179 
    if self.orderId is not None:
22180 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
22181 
      oprot.writeI64(self.orderId)
22182 
      oprot.writeFieldEnd()
22183 
    oprot.writeFieldStop()
22184 
    oprot.writeStructEnd()
22185 
 
22186 
  def validate(self):
22187 
    return
22188 
 
22189 
 
22190 
  def __repr__(self):
22191 
    L = ['%s=%r' % (key, value)
22192 
      for key, value in self.__dict__.iteritems()]
22193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22194 
 
22195 
  def __eq__(self, other):
22196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22197 
 
22198 
  def __ne__(self, other):
22199 
    return not (self == other)
22200 
 
22201 
class updateCODAgent_result:
22202 
  """
22203 
  Attributes:
22204 
   - ex
22205 
  """
22206 
 
22207 
  thrift_spec = (
22208 
    None, # 0
22209 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22210 
  )
22211 
 
22212 
  def __init__(self, ex=None,):
22213 
    self.ex = ex
22214 
 
22215 
  def read(self, iprot):
22216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22218 
      return
22219 
    iprot.readStructBegin()
22220 
    while True:
22221 
      (fname, ftype, fid) = iprot.readFieldBegin()
22222 
      if ftype == TType.STOP:
22223 
        break
22224 
      if fid == 1:
22225 
        if ftype == TType.STRUCT:
22226 
          self.ex = TransactionServiceException()
22227 
          self.ex.read(iprot)
22228 
        else:
22229 
          iprot.skip(ftype)
22230 
      else:
22231 
        iprot.skip(ftype)
22232 
      iprot.readFieldEnd()
22233 
    iprot.readStructEnd()
22234 
 
22235 
  def write(self, oprot):
22236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22238 
      return
22239 
    oprot.writeStructBegin('updateCODAgent_result')
22240 
    if self.ex is not None:
22241 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22242 
      self.ex.write(oprot)
22243 
      oprot.writeFieldEnd()
22244 
    oprot.writeFieldStop()
22245 
    oprot.writeStructEnd()
22246 
 
22247 
  def validate(self):
22248 
    return
22249 
 
22250 
 
22251 
  def __repr__(self):
22252 
    L = ['%s=%r' % (key, value)
22253 
      for key, value in self.__dict__.iteritems()]
22254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22255 
 
22256 
  def __eq__(self, other):
22257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22258 
 
22259 
  def __ne__(self, other):
22260 
    return not (self == other)
22261 
 
5099 varun.gupt 22262 
class updateOrderAsPaidToVendor_args:
22263 
  """
22264 
  Attributes:
22265 
   - orderId
22266 
  """
22267 
 
22268 
  thrift_spec = (
22269 
    None, # 0
22270 
    (1, TType.I64, 'orderId', None, None, ), # 1
22271 
  )
22272 
 
22273 
  def __init__(self, orderId=None,):
22274 
    self.orderId = orderId
22275 
 
22276 
  def read(self, iprot):
22277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22279 
      return
22280 
    iprot.readStructBegin()
22281 
    while True:
22282 
      (fname, ftype, fid) = iprot.readFieldBegin()
22283 
      if ftype == TType.STOP:
22284 
        break
22285 
      if fid == 1:
22286 
        if ftype == TType.I64:
22287 
          self.orderId = iprot.readI64();
22288 
        else:
22289 
          iprot.skip(ftype)
22290 
      else:
22291 
        iprot.skip(ftype)
22292 
      iprot.readFieldEnd()
22293 
    iprot.readStructEnd()
22294 
 
22295 
  def write(self, oprot):
22296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22298 
      return
22299 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
22300 
    if self.orderId is not None:
22301 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22302 
      oprot.writeI64(self.orderId)
22303 
      oprot.writeFieldEnd()
22304 
    oprot.writeFieldStop()
22305 
    oprot.writeStructEnd()
22306 
 
22307 
  def validate(self):
22308 
    return
22309 
 
22310 
 
22311 
  def __repr__(self):
22312 
    L = ['%s=%r' % (key, value)
22313 
      for key, value in self.__dict__.iteritems()]
22314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22315 
 
22316 
  def __eq__(self, other):
22317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22318 
 
22319 
  def __ne__(self, other):
22320 
    return not (self == other)
22321 
 
22322 
class updateOrderAsPaidToVendor_result:
22323 
  """
22324 
  Attributes:
22325 
   - ex
22326 
  """
22327 
 
22328 
  thrift_spec = (
22329 
    None, # 0
22330 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22331 
  )
22332 
 
22333 
  def __init__(self, ex=None,):
22334 
    self.ex = ex
22335 
 
22336 
  def read(self, iprot):
22337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22339 
      return
22340 
    iprot.readStructBegin()
22341 
    while True:
22342 
      (fname, ftype, fid) = iprot.readFieldBegin()
22343 
      if ftype == TType.STOP:
22344 
        break
22345 
      if fid == 1:
22346 
        if ftype == TType.STRUCT:
22347 
          self.ex = TransactionServiceException()
22348 
          self.ex.read(iprot)
22349 
        else:
22350 
          iprot.skip(ftype)
22351 
      else:
22352 
        iprot.skip(ftype)
22353 
      iprot.readFieldEnd()
22354 
    iprot.readStructEnd()
22355 
 
22356 
  def write(self, oprot):
22357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22359 
      return
22360 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
22361 
    if self.ex is not None:
22362 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22363 
      self.ex.write(oprot)
22364 
      oprot.writeFieldEnd()
22365 
    oprot.writeFieldStop()
22366 
    oprot.writeStructEnd()
22367 
 
22368 
  def validate(self):
22369 
    return
22370 
 
22371 
 
22372 
  def __repr__(self):
22373 
    L = ['%s=%r' % (key, value)
22374 
      for key, value in self.__dict__.iteritems()]
22375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22376 
 
22377 
  def __eq__(self, other):
22378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22379 
 
22380 
  def __ne__(self, other):
22381 
    return not (self == other)
5208 varun.gupt 22382 
 
22383 
class getRefundedOrdersMarkedPaid_args:
22384 
 
22385 
  thrift_spec = (
22386 
  )
22387 
 
22388 
  def read(self, iprot):
22389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22391 
      return
22392 
    iprot.readStructBegin()
22393 
    while True:
22394 
      (fname, ftype, fid) = iprot.readFieldBegin()
22395 
      if ftype == TType.STOP:
22396 
        break
22397 
      else:
22398 
        iprot.skip(ftype)
22399 
      iprot.readFieldEnd()
22400 
    iprot.readStructEnd()
22401 
 
22402 
  def write(self, oprot):
22403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22405 
      return
22406 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
22407 
    oprot.writeFieldStop()
22408 
    oprot.writeStructEnd()
22409 
 
22410 
  def validate(self):
22411 
    return
22412 
 
22413 
 
22414 
  def __repr__(self):
22415 
    L = ['%s=%r' % (key, value)
22416 
      for key, value in self.__dict__.iteritems()]
22417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22418 
 
22419 
  def __eq__(self, other):
22420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22421 
 
22422 
  def __ne__(self, other):
22423 
    return not (self == other)
22424 
 
22425 
class getRefundedOrdersMarkedPaid_result:
22426 
  """
22427 
  Attributes:
22428 
   - success
22429 
   - ex
22430 
  """
22431 
 
22432 
  thrift_spec = (
22433 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22434 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22435 
  )
22436 
 
22437 
  def __init__(self, success=None, ex=None,):
22438 
    self.success = success
22439 
    self.ex = ex
22440 
 
22441 
  def read(self, iprot):
22442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22444 
      return
22445 
    iprot.readStructBegin()
22446 
    while True:
22447 
      (fname, ftype, fid) = iprot.readFieldBegin()
22448 
      if ftype == TType.STOP:
22449 
        break
22450 
      if fid == 0:
22451 
        if ftype == TType.LIST:
22452 
          self.success = []
5348 anupam.sin 22453 
          (_etype527, _size524) = iprot.readListBegin()
22454 
          for _i528 in xrange(_size524):
22455 
            _elem529 = Order()
22456 
            _elem529.read(iprot)
22457 
            self.success.append(_elem529)
5208 varun.gupt 22458 
          iprot.readListEnd()
22459 
        else:
22460 
          iprot.skip(ftype)
22461 
      elif fid == 1:
22462 
        if ftype == TType.STRUCT:
22463 
          self.ex = TransactionServiceException()
22464 
          self.ex.read(iprot)
22465 
        else:
22466 
          iprot.skip(ftype)
22467 
      else:
22468 
        iprot.skip(ftype)
22469 
      iprot.readFieldEnd()
22470 
    iprot.readStructEnd()
22471 
 
22472 
  def write(self, oprot):
22473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22475 
      return
22476 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
22477 
    if self.success is not None:
22478 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22479 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5348 anupam.sin 22480 
      for iter530 in self.success:
22481 
        iter530.write(oprot)
5208 varun.gupt 22482 
      oprot.writeListEnd()
22483 
      oprot.writeFieldEnd()
22484 
    if self.ex is not None:
22485 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22486 
      self.ex.write(oprot)
22487 
      oprot.writeFieldEnd()
22488 
    oprot.writeFieldStop()
22489 
    oprot.writeStructEnd()
22490 
 
22491 
  def validate(self):
22492 
    return
22493 
 
22494 
 
22495 
  def __repr__(self):
22496 
    L = ['%s=%r' % (key, value)
22497 
      for key, value in self.__dict__.iteritems()]
22498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22499 
 
22500 
  def __eq__(self, other):
22501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22502 
 
22503 
  def __ne__(self, other):
22504 
    return not (self == other)