Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
58 
  def changeTransactionStatus(self, transactionId, status, description):
59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
64 
    """
65 
    pass
66 
 
1398 varun.gupt 67 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 68 
    """
69 
    Parameters:
70 
     - transactionId
71 
    """
72 
    pass
73 
 
4801 anupam.sin 74 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 75 
    """
76 
    Parameters:
4801 anupam.sin 77 
     - statuses
483 rajveer 78 
     - from_date
79 
     - to_date
80 
     - warehouse_id
94 ashish 81 
    """
82 
    pass
83 
 
4133 chandransh 84 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
85 
    """
86 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
87 
    Pass the status as null and the limit as 0 to ignore them.
88 
 
89 
    Parameters:
90 
     - statuses
91 
     - offset
92 
     - limit
93 
     - warehouse_id
94 
    """
95 
    pass
96 
 
97 
  def getOrderCount(self, statuses, warehouseId):
98 
    """
99 
    Returns the count of orders with the given statuses assigned to the given warehouse.
100 
 
101 
    Parameters:
102 
     - statuses
103 
     - warehouseId
104 
    """
105 
    pass
106 
 
999 varun.gupt 107 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
108 
    """
1132 chandransh 109 
    Returns orders within a range of their billing dates
3431 rajveer 110 
 
999 varun.gupt 111 
    Parameters:
112 
     - status
113 
     - start_billing_date
114 
     - end_billing_date
115 
     - warehouse_id
116 
    """
117 
    pass
118 
 
3451 chandransh 119 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 120 
    """
121 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 122 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
123 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 124 
 
3427 chandransh 125 
    Parameters:
126 
     - fromShippingDate
127 
     - toShippingDate
128 
     - providerId
129 
     - warehouseId
3451 chandransh 130 
     - cod
3427 chandransh 131 
    """
132 
    pass
133 
 
1382 varun.gupt 134 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
135 
    """
136 
    Returns order ids for orders which can be returned
3431 rajveer 137 
 
1382 varun.gupt 138 
    Parameters:
139 
     - customer_id
140 
     - limit
141 
    """
142 
    pass
143 
 
144 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
145 
    """
146 
    Returns order ids for orders which can be cancelled
3431 rajveer 147 
 
1382 varun.gupt 148 
    Parameters:
149 
     - customer_id
150 
     - limit
151 
    """
152 
    pass
153 
 
483 rajveer 154 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 155 
    """
156 
    Parameters:
483 rajveer 157 
     - orderId
158 
     - status
159 
     - description
94 ashish 160 
    """
161 
    pass
162 
 
1528 ankur.sing 163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 164 
    """
1528 ankur.sing 165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
166 
    only user who owns the transaction can view its order details.
3431 rajveer 167 
 
94 ashish 168 
    Parameters:
169 
     - transactionId
1528 ankur.sing 170 
     - customerId
94 ashish 171 
    """
172 
    pass
173 
 
3014 chandransh 174 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 175 
    """
3014 chandransh 176 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
177 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 178 
 
94 ashish 179 
    Parameters:
483 rajveer 180 
     - customerId
181 
     - from_date
182 
     - to_date
3014 chandransh 183 
     - statuses
94 ashish 184 
    """
185 
    pass
186 
 
483 rajveer 187 
  def createOrder(self, order):
94 ashish 188 
    """
189 
    Parameters:
483 rajveer 190 
     - order
94 ashish 191 
    """
192 
    pass
193 
 
483 rajveer 194 
  def getOrder(self, id):
94 ashish 195 
    """
196 
    Parameters:
483 rajveer 197 
     - id
94 ashish 198 
    """
199 
    pass
200 
 
483 rajveer 201 
  def getLineItemsForOrder(self, orderId):
94 ashish 202 
    """
203 
    Parameters:
483 rajveer 204 
     - orderId
94 ashish 205 
    """
206 
    pass
207 
 
4999 phani.kuma 208 
  def getOrderList(self, order_ids):
209 
    """
210 
    Parameters:
211 
     - order_ids
212 
    """
213 
    pass
214 
 
1528 ankur.sing 215 
  def getOrderForCustomer(self, orderId, customerId):
216 
    """
217 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
218 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 219 
 
1528 ankur.sing 220 
    Parameters:
221 
     - orderId
222 
     - customerId
223 
    """
224 
    pass
225 
 
4444 rajveer 226 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 227 
    """
228 
    Parameters:
4394 rajveer 229 
     - type
4444 rajveer 230 
     - warehouseId
4394 rajveer 231 
     - status
232 
     - timestamp
3064 chandransh 233 
    """
234 
    pass
235 
 
4444 rajveer 236 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 237 
    """
238 
    Parameters:
239 
     - type
4444 rajveer 240 
     - warehouseId
4394 rajveer 241 
     - description
3064 chandransh 242 
    """
243 
    pass
244 
 
4444 rajveer 245 
  def markAlertsAsSeen(self, warehouseId):
246 
    """
247 
    Parameters:
248 
     - warehouseId
249 
    """
250 
    pass
251 
 
3064 chandransh 252 
  def getValidOrderCount(self, ):
253 
    """
254 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
255 
    """
256 
    pass
257 
 
258 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
259 
    """
260 
    Returns the number of distinct customers who have done successful transactions
261 
    """
262 
    pass
263 
 
264 
  def getValidOrdersAmountRange(self, ):
265 
    """
266 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
267 
    List contains two values, first minimum amount and second maximum amount.
268 
    """
269 
    pass
270 
 
271 
  def getValidOrders(self, limit):
272 
    """
273 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
274 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 275 
 
3064 chandransh 276 
    Parameters:
277 
     - limit
278 
    """
279 
    pass
280 
 
1220 chandransh 281 
  def batchOrders(self, warehouseId):
282 
    """
283 
    Create a batch of all the pending orders for the given warehouse.
284 
    The returned list is orderd by created_timestamp.
285 
    If there are no pending orders, an empty list is returned.
3431 rajveer 286 
 
1220 chandransh 287 
    Parameters:
288 
     - warehouseId
289 
    """
290 
    pass
291 
 
1208 chandransh 292 
  def markOrderAsOutOfStock(self, orderId):
293 
    """
294 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 295 
 
1208 chandransh 296 
    Parameters:
297 
     - orderId
298 
    """
299 
    pass
300 
 
3064 chandransh 301 
  def verifyOrder(self, orderId):
759 chandransh 302 
    """
3064 chandransh 303 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
304 
    timestamp. It is intended to be used for COD orders but can be harmlessly
305 
    used for all other orders as well.
306 
    Throws an exception if no such order exists.
3431 rajveer 307 
 
759 chandransh 308 
    Parameters:
3064 chandransh 309 
     - orderId
310 
    """
311 
    pass
312 
 
313 
  def acceptOrder(self, orderId):
314 
    """
315 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
316 
    given order is not a COD order, it also captures the payment if the same has
317 
    not been captured.
318 
    Throws an exception if no such order exists.
3431 rajveer 319 
 
3064 chandransh 320 
    Parameters:
321 
     - orderId
322 
    """
323 
    pass
324 
 
5110 mandeep.dh 325 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 326 
    """
327 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 328 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 329 
    the IMEI no. if a -1 is supplied.
330 
    Also, it generates an invoice number for the order, marks the order as
331 
    BILLED and sets the billing timestamp.
332 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 333 
 
3064 chandransh 334 
    Parameters:
335 
     - orderId
4283 anupam.sin 336 
     - invoice_number
4658 mandeep.dh 337 
     - serialNumber
3064 chandransh 338 
     - itemNumber
4283 anupam.sin 339 
     - billed_by
340 
     - jacketNumber
3064 chandransh 341 
     - billingType
5110 mandeep.dh 342 
     - fulfilmentWarehouseId
4763 rajveer 343 
     - authorize
3064 chandransh 344 
    """
345 
    pass
346 
 
4763 rajveer 347 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 348 
    """
349 
    Add the invoice number to the order.
350 
 
351 
    Parameters:
352 
     - orderId
353 
     - invoiceNumber
4763 rajveer 354 
     - color
4579 rajveer 355 
    """
356 
    pass
357 
 
4910 phani.kuma 358 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 359 
    """
360 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 361 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 362 
 
363 
    Parameters:
364 
     - warehouseId
365 
     - providerId
366 
     - cod
4910 phani.kuma 367 
     - orderIds
4410 rajveer 368 
    """
369 
    pass
370 
 
4910 phani.kuma 371 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 372 
    """
4910 phani.kuma 373 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
374 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 375 
 
3064 chandransh 376 
    Parameters:
759 chandransh 377 
     - providerId
4910 phani.kuma 378 
     - pickupDetails
759 chandransh 379 
    """
380 
    pass
381 
 
4910 phani.kuma 382 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 383 
    """
384 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 385 
 
1113 chandransh 386 
    Parameters:
387 
     - providerId
388 
    """
389 
    pass
390 
 
1132 chandransh 391 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
392 
    """
393 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
394 
    the name of the receiver.
395 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 396 
 
1132 chandransh 397 
    Parameters:
398 
     - providerId
399 
     - deliveredOrders
400 
    """
401 
    pass
402 
 
4910 phani.kuma 403 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 404 
    """
4910 phani.kuma 405 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 406 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 407 
 
1135 chandransh 408 
    Parameters:
409 
     - providerId
410 
     - returnedOrders
411 
    """
412 
    pass
413 
 
4910 phani.kuma 414 
  def getRTOrders(self, providerId):
415 
    """
416 
    Returns a list of orders that were returned by courier.
417 
 
418 
    Parameters:
419 
     - providerId
420 
    """
421 
    pass
422 
 
1246 chandransh 423 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
424 
    """
425 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 426 
 
1246 chandransh 427 
    Parameters:
428 
     - providerId
429 
     - undeliveredOrders
430 
    """
431 
    pass
432 
 
4910 phani.kuma 433 
  def getNonDeliveredOrdersbyCourier(self, providerId):
434 
    """
435 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
436 
 
437 
    Parameters:
438 
     - providerId
439 
    """
440 
    pass
441 
 
442 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
443 
    """
444 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
445 
 
446 
    Parameters:
447 
     - providerId
448 
     - local_connected_orders
449 
    """
450 
    pass
451 
 
452 
  def getOrdersNotLocalConnected(self, providerId):
453 
    """
454 
    Returns a list of orders that were picked up or shipped but pending local connection.
455 
 
456 
    Parameters:
457 
     - providerId
458 
    """
459 
    pass
460 
 
461 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
462 
    """
463 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
464 
 
465 
    Parameters:
466 
     - providerId
467 
     - destination_city_reached_orders
468 
    """
469 
    pass
470 
 
471 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
472 
    """
473 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
474 
 
475 
    Parameters:
476 
     - providerId
477 
     - first_atdl_orders
478 
    """
479 
    pass
480 
 
1408 ankur.sing 481 
  def getUndeliveredOrders(self, providerId, warehouseId):
482 
    """
483 
    Returns the list of orders whose delivery time has passed but have not been
484 
    delivered yet for the given provider and warehouse. To get a complete list of
485 
    undelivered orders, pass them as -1.
486 
    Returns an empty list if no such orders exist.
3431 rajveer 487 
 
1408 ankur.sing 488 
    Parameters:
489 
     - providerId
490 
     - warehouseId
491 
    """
492 
    pass
493 
 
4783 phani.kuma 494 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
495 
    """
496 
    Returns the list of orders whose expected delivery date has passed but have not been
497 
    delivered yet.
498 
    Returns an empty list if no such orders exist.
499 
    """
500 
    pass
501 
 
2536 chandransh 502 
  def toggleDOAFlag(self, orderId):
503 
    """
504 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
505 
    Returns the final flag status.
506 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 507 
 
2536 chandransh 508 
    Parameters:
509 
     - orderId
510 
    """
511 
    pass
1886 ankur.sing 512 
 
4712 rajveer 513 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
514 
    """
515 
    Parameters:
516 
     - orderId
517 
     - deliveryTimestamp
518 
     - receiver
519 
    """
520 
    pass
521 
 
4454 rajveer 522 
  def markOrderDoaRequestReceived(self, orderId):
523 
    """
524 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
525 
 
526 
    Parameters:
527 
     - orderId
528 
    """
529 
    pass
530 
 
531 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
532 
    """
533 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
534 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
535 
 
536 
    Parameters:
537 
     - orderId
538 
     - isAuthorized
539 
    """
540 
    pass
541 
 
4488 rajveer 542 
  def markOrderReturnRequestReceived(self, orderId):
543 
    """
544 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
545 
 
546 
    Parameters:
547 
     - orderId
548 
    """
549 
    pass
550 
 
551 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
552 
    """
553 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
554 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
555 
 
556 
    Parameters:
557 
     - orderId
558 
     - isAuthorized
559 
    """
560 
    pass
561 
 
4579 rajveer 562 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 563 
    """
564 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 565 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
566 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 567 
    For any other status, it returns false.
568 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 569 
 
2536 chandransh 570 
    Parameters:
571 
     - orderId
4579 rajveer 572 
     - providerId
2536 chandransh 573 
    """
574 
    pass
575 
 
4602 rajveer 576 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 577 
    """
4452 rajveer 578 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 579 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
580 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
581 
    	3. Returns true
2591 chandransh 582 
    If the order is in any other status, it returns false.
2536 chandransh 583 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 584 
 
2536 chandransh 585 
    Parameters:
586 
     - orderId
587 
     - pickupNumber
4602 rajveer 588 
     - providerId
2536 chandransh 589 
    """
590 
    pass
591 
 
2764 chandransh 592 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
593 
    """
594 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 595 
 
2764 chandransh 596 
    Parameters:
597 
     - providerId
598 
     - pickupDetails
599 
    """
600 
    pass
601 
 
4910 phani.kuma 602 
  def getDoasNotPickedUp(self, providerId):
603 
    """
604 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
605 
 
606 
    Parameters:
607 
     - providerId
608 
    """
609 
    pass
610 
 
4741 phani.kuma 611 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
612 
    """
613 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
614 
 
615 
    Parameters:
616 
     - providerId
617 
     - pickupDetails
618 
    """
619 
    pass
620 
 
4910 phani.kuma 621 
  def getReturnOrdersNotPickedUp(self, providerId):
622 
    """
623 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
624 
 
625 
    Parameters:
626 
     - providerId
627 
    """
628 
    pass
629 
 
4479 rajveer 630 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 631 
    """
4452 rajveer 632 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 633 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 634 
    If the order is in any other state, it returns false.
635 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 636 
 
2591 chandransh 637 
    Parameters:
638 
     - orderId
4479 rajveer 639 
     - receiveCondition
2591 chandransh 640 
    """
641 
    pass
2536 chandransh 642 
 
2591 chandransh 643 
  def validateDoa(self, orderId, isValid):
644 
    """
4452 rajveer 645 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 646 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 647 
    If the order is in any other state, it returns false.
648 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 649 
 
2591 chandransh 650 
    Parameters:
651 
     - orderId
652 
     - isValid
653 
    """
654 
    pass
655 
 
4495 rajveer 656 
  def validateReturnProduct(self, orderId, isUsable):
657 
    """
658 
    Parameters:
659 
     - orderId
660 
     - isUsable
661 
    """
662 
    pass
663 
 
2616 chandransh 664 
  def reshipOrder(self, orderId):
665 
    """
4484 rajveer 666 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 667 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 668 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 669 
 
670 
    If the order is in DOA_CERT_VALID state, it does the following:
671 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
672 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 673 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 674 
 
2616 chandransh 675 
    Returns the id of the newly created order.
3431 rajveer 676 
 
2616 chandransh 677 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 678 
 
2616 chandransh 679 
    Parameters:
680 
     - orderId
681 
    """
682 
    pass
2591 chandransh 683 
 
3226 chandransh 684 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 685 
    """
4484 rajveer 686 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 687 
    	1. Creates a refund request for batch processing.
688 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 689 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 690 
 
2616 chandransh 691 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
692 
    	1. Creates a refund request for batch processing.
3226 chandransh 693 
    	2. Cancels the reservation of the item in the warehouse.
694 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 695 
 
3226 chandransh 696 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
697 
    	1. Cancels the reservation of the item in the warehouse.
698 
    	2. Marks the current order as CANCELED.
699 
 
700 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
701 
 
2616 chandransh 702 
    Returns True if it is successful, False otherwise.
3431 rajveer 703 
 
2616 chandransh 704 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 705 
 
2616 chandransh 706 
    Parameters:
707 
     - orderId
3226 chandransh 708 
     - refundedBy
709 
     - reason
2616 chandransh 710 
    """
711 
    pass
712 
 
2690 chandransh 713 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
714 
    """
715 
    Get all return orders created between the from and to dates for the given warehouse.
716 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 717 
 
2690 chandransh 718 
    Parameters:
719 
     - warehouseId
720 
     - fromDate
721 
     - toDate
722 
    """
723 
    pass
2616 chandransh 724 
 
2700 chandransh 725 
  def getReturnOrder(self, id):
726 
    """
727 
    Returns the ReturnOrder corresponding to the given id.
728 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 729 
 
2700 chandransh 730 
    Parameters:
731 
     - id
732 
    """
733 
    pass
734 
 
2690 chandransh 735 
  def processReturn(self, returnOrderId):
736 
    """
737 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 738 
 
2690 chandransh 739 
    Parameters:
740 
     - returnOrderId
741 
    """
742 
    pass
743 
 
3451 chandransh 744 
  def updateWeight(self, orderId, weight):
745 
    """
746 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 747 
 
3451 chandransh 748 
    Parameters:
749 
     - orderId
750 
     - weight
751 
    """
752 
    pass
753 
 
3469 chandransh 754 
  def changeItem(self, orderId, itemId):
755 
    """
756 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
757 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 758 
 
3469 chandransh 759 
    Parameters:
760 
     - orderId
761 
     - itemId
762 
    """
763 
    pass
764 
 
765 
  def shiftToWarehouse(self, orderId, warehouseId):
766 
    """
767 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
768 
 
769 
    Parameters:
770 
     - orderId
771 
     - warehouseId
772 
    """
773 
    pass
774 
 
4647 rajveer 775 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 776 
    """
777 
    Adds the given delay reason to the given order.
3986 chandransh 778 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 779 
    Raises an exception if no order with the given id can be found.
3469 chandransh 780 
 
3553 chandransh 781 
    Parameters:
782 
     - orderId
783 
     - delayReason
3986 chandransh 784 
     - furtherDelay
4647 rajveer 785 
     - delayReasonText
3553 chandransh 786 
    """
787 
    pass
788 
 
3956 chandransh 789 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
790 
    """
791 
    Marks the COD orders with given AWB nos. as having been processed.
792 
    Updates the captured amount for the corresponding payment.
3553 chandransh 793 
 
3956 chandransh 794 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
795 
    1. There is no order corresponding to an AWB number.
796 
    2. The captured amount for a payment exceeds the total payment.
797 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
798 
 
799 
    Parameters:
800 
     - collectedAmountMap
801 
     - xferBy
802 
     - xferTxnId
803 
     - xferDate
804 
    """
805 
    pass
806 
 
4008 mandeep.dh 807 
  def getTransactionsRequiringExtraProcessing(self, category):
808 
    """
4065 mandeep.dh 809 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 810 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 811 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 812 
 
4008 mandeep.dh 813 
    Parameters:
814 
     - category
815 
    """
816 
    pass
817 
 
818 
  def markTransactionAsProcessed(self, transactionId, category):
819 
    """
820 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 821 
    It essentially deletes the transaction id record for a particular
822 
    processing type category (if present) from DB.
823 
    This is currently used by CRM application.
4008 mandeep.dh 824 
 
825 
    Parameters:
826 
     - transactionId
827 
     - category
828 
    """
829 
    pass
830 
 
4018 chandransh 831 
  def getItemWiseRiskyOrdersCount(self, ):
832 
    """
833 
    Returns a map containing the number of risky orders keyed by item id. A risky order
834 
    is defined as one whose shipping date is about to expire.
835 
    """
836 
    pass
4008 mandeep.dh 837 
 
4295 varun.gupt 838 
  def getOrdersForItemIds(self, itemIds):
839 
    """
840 
    Returns a list of all orders which have items with given id
841 
 
842 
    Parameters:
843 
     - itemIds
844 
    """
845 
    pass
846 
 
4247 rajveer 847 
  def markOrderCancellationRequestReceived(self, orderId):
848 
    """
849 
    Mark order as cancellation request received. If customer sends request of cancellation of
850 
    a particular order, this method will be called. It will just change status of the order
851 
    depending on its current status. It also records the previous status, so that we can move
852 
    back to that status if cancellation request is denied.
4018 chandransh 853 
 
4247 rajveer 854 
    Parameters:
855 
     - orderId
856 
    """
857 
    pass
858 
 
859 
  def markOrderCancellationRequestConfirmed(self, orderId):
860 
    """
861 
    If we decide to to cancel order, CRM will call this method to move the status of order to
862 
    cancellation request confirmed. After this OM will be able to cancel the order.
863 
 
864 
    Parameters:
865 
     - orderId
866 
    """
867 
    pass
868 
 
869 
  def markOrderCancellationRequestDenied(self, orderId):
870 
    """
871 
    If we decide to not to cancel order, we will move the order ro previous status.
872 
 
873 
    Parameters:
874 
     - orderId
875 
    """
876 
    pass
877 
 
4258 rajveer 878 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 879 
    """
4258 rajveer 880 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
881 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 882 
 
883 
    Parameters:
4258 rajveer 884 
     - transactionId
4247 rajveer 885 
    """
886 
    pass
887 
 
4259 anupam.sin 888 
  def refundTransaction(self, transactionId, refundedBy, reason):
889 
    """
890 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
891 
    need to be cancelled
4247 rajveer 892 
 
4259 anupam.sin 893 
    Parameters:
894 
     - transactionId
895 
     - refundedBy
896 
     - reason
897 
    """
898 
    pass
899 
 
4324 mandeep.dh 900 
  def updateShipmentAddress(self, orderId, addressId):
901 
    """
902 
    Updates shipment address of an order. Delivery and shipping date estimates
903 
    etc. are also updated here.
904 
 
905 
    Throws TransactionServiceException in case address change is not
906 
    possible due to certain reasons such as new pincode in address is
907 
    not serviceable etc.
908 
 
909 
    Parameters:
910 
     - orderId
911 
     - addressId
912 
    """
913 
    pass
914 
 
4285 rajveer 915 
  def acceptOrdersForItemId(self, itemId, inventory):
916 
    """
917 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
918 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 919 
 
4285 rajveer 920 
    Parameters:
921 
     - itemId
922 
     - inventory
923 
    """
924 
    pass
925 
 
4369 rajveer 926 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 927 
    """
928 
    Parameters:
929 
     - vendorId
930 
     - itemId
931 
     - quantity
932 
     - estimate
4369 rajveer 933 
     - isReminder
4303 rajveer 934 
    """
935 
    pass
4285 rajveer 936 
 
4369 rajveer 937 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 938 
    """
939 
    Parameters:
940 
     - vendorId
941 
     - itemId
942 
     - quantity
943 
     - estimate
4369 rajveer 944 
     - isReminder
4303 rajveer 945 
    """
946 
    pass
947 
 
4369 rajveer 948 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 949 
    """
950 
    Parameters:
951 
     - vendorId
952 
     - itemId
953 
     - quantity
954 
     - estimate
4369 rajveer 955 
     - isReminder
4303 rajveer 956 
    """
957 
    pass
958 
 
4369 rajveer 959 
  def markOrdersAsTimeout(self, vendorId):
960 
    """
961 
    Parameters:
962 
     - vendorId
963 
    """
964 
    pass
4303 rajveer 965 
 
4662 rajveer 966 
  def markOrderAsLostInTransit(self, orderId):
967 
    """
968 
    Mark order as LOST_IN_TRANSIT
969 
 
970 
    Parameters:
971 
     - orderId
972 
    """
973 
    pass
974 
 
4386 anupam.sin 975 
  def getOrderForAwb(self, awb):
976 
    """
977 
    Returns the order corresponding to an AWB number
4369 rajveer 978 
 
4386 anupam.sin 979 
    Parameters:
980 
     - awb
981 
    """
982 
    pass
983 
 
4910 phani.kuma 984 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 985 
    """
4910 phani.kuma 986 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 987 
 
4506 phani.kuma 988 
    Parameters:
989 
     - logistics_provider_id
4910 phani.kuma 990 
     - order_status_list
4506 phani.kuma 991 
    """
992 
    pass
993 
 
4600 varun.gupt 994 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
995 
    """
996 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 997 
 
4600 varun.gupt 998 
    Parameters:
999 
     - vendorId
1000 
     - billingDateFrom
1001 
     - billingDateTo
1002 
    """
1003 
    pass
1004 
 
4607 rajveer 1005 
  def getSlippedSippingDateOrders(self, ):
1006 
    pass
1007 
 
4709 rajveer 1008 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1009 
    """
1010 
    Parameters:
1011 
     - cancelDateFrom
1012 
     - cancelDateTo
1013 
    """
1014 
    pass
1015 
 
4600 varun.gupt 1016 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1017 
    """
1018 
    Parameters:
1019 
     - mapAWBAndAmount
1020 
    """
1021 
    pass
1022 
 
4905 varun.gupt 1023 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1024 
    """
1025 
    Parameters:
1026 
     - settlementDate
1027 
     - paymentGatewayId
4905 varun.gupt 1028 
     - referenceId
4600 varun.gupt 1029 
     - serviceTax
1030 
     - otherCharges
1031 
     - netCollection
1032 
    """
1033 
    pass
1034 
 
1035 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1036 
    """
1037 
    Parameters:
1038 
     - settlementId
1039 
     - settlementDate
1040 
     - transactionDateFrom
1041 
     - transactionDateTo
1042 
     - amount
1043 
    """
1044 
    pass
1045 
 
5189 varun.gupt 1046 
  def getSettlementForReferenceId(self, referenceId, isRefund):
4600 varun.gupt 1047 
    """
1048 
    Parameters:
5189 varun.gupt 1049 
     - referenceId
1050 
     - isRefund
4600 varun.gupt 1051 
    """
1052 
    pass
1053 
 
1054 
  def getEBSSettlementSummaries(self, ):
1055 
    pass
1056 
 
1057 
  def markEBSSettlementUploaded(self, settlementId):
1058 
    """
1059 
    Parameters:
1060 
     - settlementId
1061 
    """
1062 
    pass
1063 
 
1064 
  def getEBSSettlementDate(self, settlementId):
1065 
    """
1066 
    Parameters:
1067 
     - settlementId
1068 
    """
1069 
    pass
1070 
 
4715 varun.gupt 1071 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1072 
    """
1073 
    Parameters:
1074 
     - settlementDateFrom
1075 
     - settlementDateTo
1076 
     - isRefund
1077 
    """
1078 
    pass
4600 varun.gupt 1079 
 
4715 varun.gupt 1080 
  def getReshippedOrderIds(self, orderIds):
1081 
    """
1082 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1083 
 
1084 
    Parameters:
1085 
     - orderIds
1086 
    """
1087 
    pass
1088 
 
4875 varun.gupt 1089 
  def getOrdersWhereVendorNotPaid(self, vendorId):
1090 
    """
1091 
    Parameters:
1092 
     - vendorId
1093 
    """
1094 
    pass
4757 mandeep.dh 1095 
 
5031 varun.gupt 1096 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1097 
    """
1098 
    Parameters:
1099 
     - startDate
1100 
     - endDate
1101 
    """
1102 
    pass
4875 varun.gupt 1103 
 
5067 varun.gupt 1104 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1105 
    """
1106 
    Parameters:
1107 
     - status
1108 
     - startDatetime
1109 
     - endDatetime
1110 
    """
1111 
    pass
5031 varun.gupt 1112 
 
5099 varun.gupt 1113 
  def updateOrderAsPaidToVendor(self, orderId):
1114 
    """
1115 
    Parameters:
1116 
     - orderId
1117 
    """
1118 
    pass
5067 varun.gupt 1119 
 
5208 varun.gupt 1120 
  def getRefundedOrdersMarkedPaid(self, ):
1121 
    pass
5099 varun.gupt 1122 
 
5208 varun.gupt 1123 
 
3376 rajveer 1124 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1125 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1126 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1127 
 
1128 
  def createTransaction(self, transaction):
1129 
    """
1130 
    Parameters:
1131 
     - transaction
1132 
    """
1133 
    self.send_createTransaction(transaction)
132 ashish 1134 
    return self.recv_createTransaction()
94 ashish 1135 
 
1136 
  def send_createTransaction(self, transaction):
1137 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1138 
    args = createTransaction_args()
1139 
    args.transaction = transaction
1140 
    args.write(self._oprot)
1141 
    self._oprot.writeMessageEnd()
1142 
    self._oprot.trans.flush()
1143 
 
1144 
  def recv_createTransaction(self, ):
1145 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1146 
    if mtype == TMessageType.EXCEPTION:
1147 
      x = TApplicationException()
1148 
      x.read(self._iprot)
1149 
      self._iprot.readMessageEnd()
1150 
      raise x
1151 
    result = createTransaction_result()
1152 
    result.read(self._iprot)
1153 
    self._iprot.readMessageEnd()
3431 rajveer 1154 
    if result.success is not None:
132 ashish 1155 
      return result.success
3431 rajveer 1156 
    if result.ex is not None:
94 ashish 1157 
      raise result.ex
132 ashish 1158 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1159 
 
1160 
  def getTransaction(self, id):
1161 
    """
1162 
    Parameters:
1163 
     - id
1164 
    """
1165 
    self.send_getTransaction(id)
1166 
    return self.recv_getTransaction()
1167 
 
1168 
  def send_getTransaction(self, id):
1169 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1170 
    args = getTransaction_args()
1171 
    args.id = id
1172 
    args.write(self._oprot)
1173 
    self._oprot.writeMessageEnd()
1174 
    self._oprot.trans.flush()
1175 
 
1176 
  def recv_getTransaction(self, ):
1177 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1178 
    if mtype == TMessageType.EXCEPTION:
1179 
      x = TApplicationException()
1180 
      x.read(self._iprot)
1181 
      self._iprot.readMessageEnd()
1182 
      raise x
1183 
    result = getTransaction_result()
1184 
    result.read(self._iprot)
1185 
    self._iprot.readMessageEnd()
3431 rajveer 1186 
    if result.success is not None:
94 ashish 1187 
      return result.success
3431 rajveer 1188 
    if result.ex is not None:
94 ashish 1189 
      raise result.ex
1190 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1191 
 
1192 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1193 
    """
1194 
    Parameters:
1195 
     - customerId
1196 
     - from_date
1197 
     - to_date
1198 
     - status
1199 
    """
1200 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1201 
    return self.recv_getTransactionsForCustomer()
1202 
 
1203 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1204 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1205 
    args = getTransactionsForCustomer_args()
1206 
    args.customerId = customerId
1207 
    args.from_date = from_date
1208 
    args.to_date = to_date
1209 
    args.status = status
1210 
    args.write(self._oprot)
1211 
    self._oprot.writeMessageEnd()
1212 
    self._oprot.trans.flush()
1213 
 
1214 
  def recv_getTransactionsForCustomer(self, ):
1215 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1216 
    if mtype == TMessageType.EXCEPTION:
1217 
      x = TApplicationException()
1218 
      x.read(self._iprot)
1219 
      self._iprot.readMessageEnd()
1220 
      raise x
1221 
    result = getTransactionsForCustomer_result()
1222 
    result.read(self._iprot)
1223 
    self._iprot.readMessageEnd()
3431 rajveer 1224 
    if result.success is not None:
94 ashish 1225 
      return result.success
3431 rajveer 1226 
    if result.ex is not None:
94 ashish 1227 
      raise result.ex
1228 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1229 
 
132 ashish 1230 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1231 
    """
1232 
    Parameters:
1233 
     - shoppingCartId
1234 
    """
1235 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1236 
    return self.recv_getTransactionsForShoppingCartId()
1237 
 
1238 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1239 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1240 
    args = getTransactionsForShoppingCartId_args()
1241 
    args.shoppingCartId = shoppingCartId
1242 
    args.write(self._oprot)
1243 
    self._oprot.writeMessageEnd()
1244 
    self._oprot.trans.flush()
1245 
 
1246 
  def recv_getTransactionsForShoppingCartId(self, ):
1247 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1248 
    if mtype == TMessageType.EXCEPTION:
1249 
      x = TApplicationException()
1250 
      x.read(self._iprot)
1251 
      self._iprot.readMessageEnd()
1252 
      raise x
1253 
    result = getTransactionsForShoppingCartId_result()
1254 
    result.read(self._iprot)
1255 
    self._iprot.readMessageEnd()
3431 rajveer 1256 
    if result.success is not None:
132 ashish 1257 
      return result.success
3431 rajveer 1258 
    if result.ex is not None:
132 ashish 1259 
      raise result.ex
1260 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1261 
 
94 ashish 1262 
  def getTransactionStatus(self, transactionId):
1263 
    """
1264 
    Parameters:
1265 
     - transactionId
1266 
    """
1267 
    self.send_getTransactionStatus(transactionId)
1268 
    return self.recv_getTransactionStatus()
1269 
 
1270 
  def send_getTransactionStatus(self, transactionId):
1271 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1272 
    args = getTransactionStatus_args()
1273 
    args.transactionId = transactionId
1274 
    args.write(self._oprot)
1275 
    self._oprot.writeMessageEnd()
1276 
    self._oprot.trans.flush()
1277 
 
1278 
  def recv_getTransactionStatus(self, ):
1279 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1280 
    if mtype == TMessageType.EXCEPTION:
1281 
      x = TApplicationException()
1282 
      x.read(self._iprot)
1283 
      self._iprot.readMessageEnd()
1284 
      raise x
1285 
    result = getTransactionStatus_result()
1286 
    result.read(self._iprot)
1287 
    self._iprot.readMessageEnd()
3431 rajveer 1288 
    if result.success is not None:
94 ashish 1289 
      return result.success
3431 rajveer 1290 
    if result.ex is not None:
94 ashish 1291 
      raise result.ex
1292 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1293 
 
1294 
  def changeTransactionStatus(self, transactionId, status, description):
1295 
    """
1296 
    Parameters:
1297 
     - transactionId
1298 
     - status
1299 
     - description
1300 
    """
1301 
    self.send_changeTransactionStatus(transactionId, status, description)
1302 
    return self.recv_changeTransactionStatus()
1303 
 
1304 
  def send_changeTransactionStatus(self, transactionId, status, description):
1305 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1306 
    args = changeTransactionStatus_args()
1307 
    args.transactionId = transactionId
1308 
    args.status = status
1309 
    args.description = description
1310 
    args.write(self._oprot)
1311 
    self._oprot.writeMessageEnd()
1312 
    self._oprot.trans.flush()
1313 
 
1314 
  def recv_changeTransactionStatus(self, ):
1315 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1316 
    if mtype == TMessageType.EXCEPTION:
1317 
      x = TApplicationException()
1318 
      x.read(self._iprot)
1319 
      self._iprot.readMessageEnd()
1320 
      raise x
1321 
    result = changeTransactionStatus_result()
1322 
    result.read(self._iprot)
1323 
    self._iprot.readMessageEnd()
3431 rajveer 1324 
    if result.success is not None:
94 ashish 1325 
      return result.success
3431 rajveer 1326 
    if result.ex is not None:
94 ashish 1327 
      raise result.ex
1328 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1329 
 
1398 varun.gupt 1330 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1331 
    """
1332 
    Parameters:
1333 
     - transactionId
1334 
    """
1398 varun.gupt 1335 
    self.send_enqueueTransactionInfoEmail(transactionId)
1336 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1337 
 
1398 varun.gupt 1338 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1339 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1340 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1341 
    args.transactionId = transactionId
1342 
    args.write(self._oprot)
1343 
    self._oprot.writeMessageEnd()
1344 
    self._oprot.trans.flush()
1345 
 
1398 varun.gupt 1346 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1348 
    if mtype == TMessageType.EXCEPTION:
1349 
      x = TApplicationException()
1350 
      x.read(self._iprot)
1351 
      self._iprot.readMessageEnd()
1352 
      raise x
1398 varun.gupt 1353 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1354 
    result.read(self._iprot)
1355 
    self._iprot.readMessageEnd()
3431 rajveer 1356 
    if result.success is not None:
1382 varun.gupt 1357 
      return result.success
3431 rajveer 1358 
    if result.ex is not None:
1382 varun.gupt 1359 
      raise result.ex
1398 varun.gupt 1360 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1361 
 
4801 anupam.sin 1362 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1363 
    """
1364 
    Parameters:
4801 anupam.sin 1365 
     - statuses
483 rajveer 1366 
     - from_date
1367 
     - to_date
1368 
     - warehouse_id
94 ashish 1369 
    """
4801 anupam.sin 1370 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1371 
    return self.recv_getAllOrders()
94 ashish 1372 
 
4801 anupam.sin 1373 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1374 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1375 
    args = getAllOrders_args()
4801 anupam.sin 1376 
    args.statuses = statuses
483 rajveer 1377 
    args.from_date = from_date
1378 
    args.to_date = to_date
1379 
    args.warehouse_id = warehouse_id
94 ashish 1380 
    args.write(self._oprot)
1381 
    self._oprot.writeMessageEnd()
1382 
    self._oprot.trans.flush()
1383 
 
483 rajveer 1384 
  def recv_getAllOrders(self, ):
94 ashish 1385 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1386 
    if mtype == TMessageType.EXCEPTION:
1387 
      x = TApplicationException()
1388 
      x.read(self._iprot)
1389 
      self._iprot.readMessageEnd()
1390 
      raise x
483 rajveer 1391 
    result = getAllOrders_result()
94 ashish 1392 
    result.read(self._iprot)
1393 
    self._iprot.readMessageEnd()
3431 rajveer 1394 
    if result.success is not None:
94 ashish 1395 
      return result.success
3431 rajveer 1396 
    if result.ex is not None:
94 ashish 1397 
      raise result.ex
483 rajveer 1398 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1399 
 
4133 chandransh 1400 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1401 
    """
1402 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1403 
    Pass the status as null and the limit as 0 to ignore them.
1404 
 
1405 
    Parameters:
1406 
     - statuses
1407 
     - offset
1408 
     - limit
1409 
     - warehouse_id
1410 
    """
1411 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1412 
    return self.recv_getOrdersInBatch()
1413 
 
1414 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1415 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1416 
    args = getOrdersInBatch_args()
1417 
    args.statuses = statuses
1418 
    args.offset = offset
1419 
    args.limit = limit
1420 
    args.warehouse_id = warehouse_id
1421 
    args.write(self._oprot)
1422 
    self._oprot.writeMessageEnd()
1423 
    self._oprot.trans.flush()
1424 
 
1425 
  def recv_getOrdersInBatch(self, ):
1426 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1427 
    if mtype == TMessageType.EXCEPTION:
1428 
      x = TApplicationException()
1429 
      x.read(self._iprot)
1430 
      self._iprot.readMessageEnd()
1431 
      raise x
1432 
    result = getOrdersInBatch_result()
1433 
    result.read(self._iprot)
1434 
    self._iprot.readMessageEnd()
1435 
    if result.success is not None:
1436 
      return result.success
1437 
    if result.ex is not None:
1438 
      raise result.ex
1439 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1440 
 
1441 
  def getOrderCount(self, statuses, warehouseId):
1442 
    """
1443 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1444 
 
1445 
    Parameters:
1446 
     - statuses
1447 
     - warehouseId
1448 
    """
1449 
    self.send_getOrderCount(statuses, warehouseId)
1450 
    return self.recv_getOrderCount()
1451 
 
1452 
  def send_getOrderCount(self, statuses, warehouseId):
1453 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1454 
    args = getOrderCount_args()
1455 
    args.statuses = statuses
1456 
    args.warehouseId = warehouseId
1457 
    args.write(self._oprot)
1458 
    self._oprot.writeMessageEnd()
1459 
    self._oprot.trans.flush()
1460 
 
1461 
  def recv_getOrderCount(self, ):
1462 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1463 
    if mtype == TMessageType.EXCEPTION:
1464 
      x = TApplicationException()
1465 
      x.read(self._iprot)
1466 
      self._iprot.readMessageEnd()
1467 
      raise x
1468 
    result = getOrderCount_result()
1469 
    result.read(self._iprot)
1470 
    self._iprot.readMessageEnd()
1471 
    if result.success is not None:
1472 
      return result.success
1473 
    if result.ex is not None:
1474 
      raise result.ex
1475 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1476 
 
999 varun.gupt 1477 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1478 
    """
1132 chandransh 1479 
    Returns orders within a range of their billing dates
3431 rajveer 1480 
 
999 varun.gupt 1481 
    Parameters:
1482 
     - status
1483 
     - start_billing_date
1484 
     - end_billing_date
1485 
     - warehouse_id
1486 
    """
1487 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1488 
    return self.recv_getOrdersByBillingDate()
1489 
 
1490 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1491 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1492 
    args = getOrdersByBillingDate_args()
1493 
    args.status = status
1494 
    args.start_billing_date = start_billing_date
1495 
    args.end_billing_date = end_billing_date
1496 
    args.warehouse_id = warehouse_id
1497 
    args.write(self._oprot)
1498 
    self._oprot.writeMessageEnd()
1499 
    self._oprot.trans.flush()
1500 
 
1501 
  def recv_getOrdersByBillingDate(self, ):
1502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1503 
    if mtype == TMessageType.EXCEPTION:
1504 
      x = TApplicationException()
1505 
      x.read(self._iprot)
1506 
      self._iprot.readMessageEnd()
1507 
      raise x
1508 
    result = getOrdersByBillingDate_result()
1509 
    result.read(self._iprot)
1510 
    self._iprot.readMessageEnd()
3431 rajveer 1511 
    if result.success is not None:
999 varun.gupt 1512 
      return result.success
3431 rajveer 1513 
    if result.ex is not None:
999 varun.gupt 1514 
      raise result.ex
1515 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1516 
 
3451 chandransh 1517 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1518 
    """
1519 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1520 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1521 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1522 
 
3427 chandransh 1523 
    Parameters:
1524 
     - fromShippingDate
1525 
     - toShippingDate
1526 
     - providerId
1527 
     - warehouseId
3451 chandransh 1528 
     - cod
3427 chandransh 1529 
    """
3451 chandransh 1530 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1531 
    return self.recv_getOrdersByShippingDate()
1532 
 
3451 chandransh 1533 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1534 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1535 
    args = getOrdersByShippingDate_args()
1536 
    args.fromShippingDate = fromShippingDate
1537 
    args.toShippingDate = toShippingDate
1538 
    args.providerId = providerId
1539 
    args.warehouseId = warehouseId
3451 chandransh 1540 
    args.cod = cod
3427 chandransh 1541 
    args.write(self._oprot)
1542 
    self._oprot.writeMessageEnd()
1543 
    self._oprot.trans.flush()
1544 
 
1545 
  def recv_getOrdersByShippingDate(self, ):
1546 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1547 
    if mtype == TMessageType.EXCEPTION:
1548 
      x = TApplicationException()
1549 
      x.read(self._iprot)
1550 
      self._iprot.readMessageEnd()
1551 
      raise x
1552 
    result = getOrdersByShippingDate_result()
1553 
    result.read(self._iprot)
1554 
    self._iprot.readMessageEnd()
3431 rajveer 1555 
    if result.success is not None:
3427 chandransh 1556 
      return result.success
3431 rajveer 1557 
    if result.ex is not None:
3427 chandransh 1558 
      raise result.ex
1559 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1560 
 
1382 varun.gupt 1561 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1562 
    """
1563 
    Returns order ids for orders which can be returned
3431 rajveer 1564 
 
1382 varun.gupt 1565 
    Parameters:
1566 
     - customer_id
1567 
     - limit
1568 
    """
1569 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1570 
    return self.recv_getReturnableOrdersForCustomer()
1571 
 
1572 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1573 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1574 
    args = getReturnableOrdersForCustomer_args()
1575 
    args.customer_id = customer_id
1576 
    args.limit = limit
1577 
    args.write(self._oprot)
1578 
    self._oprot.writeMessageEnd()
1579 
    self._oprot.trans.flush()
1580 
 
1581 
  def recv_getReturnableOrdersForCustomer(self, ):
1582 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1583 
    if mtype == TMessageType.EXCEPTION:
1584 
      x = TApplicationException()
1585 
      x.read(self._iprot)
1586 
      self._iprot.readMessageEnd()
1587 
      raise x
1588 
    result = getReturnableOrdersForCustomer_result()
1589 
    result.read(self._iprot)
1590 
    self._iprot.readMessageEnd()
3431 rajveer 1591 
    if result.success is not None:
1382 varun.gupt 1592 
      return result.success
3431 rajveer 1593 
    if result.ex is not None:
1382 varun.gupt 1594 
      raise result.ex
1595 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1596 
 
1597 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1598 
    """
1599 
    Returns order ids for orders which can be cancelled
3431 rajveer 1600 
 
1382 varun.gupt 1601 
    Parameters:
1602 
     - customer_id
1603 
     - limit
1604 
    """
1605 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1606 
    return self.recv_getCancellableOrdersForCustomer()
1607 
 
1608 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1609 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1610 
    args = getCancellableOrdersForCustomer_args()
1611 
    args.customer_id = customer_id
1612 
    args.limit = limit
1613 
    args.write(self._oprot)
1614 
    self._oprot.writeMessageEnd()
1615 
    self._oprot.trans.flush()
1616 
 
1617 
  def recv_getCancellableOrdersForCustomer(self, ):
1618 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1619 
    if mtype == TMessageType.EXCEPTION:
1620 
      x = TApplicationException()
1621 
      x.read(self._iprot)
1622 
      self._iprot.readMessageEnd()
1623 
      raise x
1624 
    result = getCancellableOrdersForCustomer_result()
1625 
    result.read(self._iprot)
1626 
    self._iprot.readMessageEnd()
3431 rajveer 1627 
    if result.success is not None:
1382 varun.gupt 1628 
      return result.success
3431 rajveer 1629 
    if result.ex is not None:
1382 varun.gupt 1630 
      raise result.ex
1631 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1632 
 
483 rajveer 1633 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1634 
    """
1635 
    Parameters:
483 rajveer 1636 
     - orderId
1637 
     - status
1638 
     - description
94 ashish 1639 
    """
483 rajveer 1640 
    self.send_changeOrderStatus(orderId, status, description)
1641 
    return self.recv_changeOrderStatus()
94 ashish 1642 
 
483 rajveer 1643 
  def send_changeOrderStatus(self, orderId, status, description):
1644 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1645 
    args = changeOrderStatus_args()
1646 
    args.orderId = orderId
1647 
    args.status = status
1648 
    args.description = description
94 ashish 1649 
    args.write(self._oprot)
1650 
    self._oprot.writeMessageEnd()
1651 
    self._oprot.trans.flush()
1652 
 
483 rajveer 1653 
  def recv_changeOrderStatus(self, ):
94 ashish 1654 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1655 
    if mtype == TMessageType.EXCEPTION:
1656 
      x = TApplicationException()
1657 
      x.read(self._iprot)
1658 
      self._iprot.readMessageEnd()
1659 
      raise x
483 rajveer 1660 
    result = changeOrderStatus_result()
94 ashish 1661 
    result.read(self._iprot)
1662 
    self._iprot.readMessageEnd()
3431 rajveer 1663 
    if result.success is not None:
94 ashish 1664 
      return result.success
3431 rajveer 1665 
    if result.ex is not None:
94 ashish 1666 
      raise result.ex
483 rajveer 1667 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1668 
 
1528 ankur.sing 1669 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1670 
    """
1528 ankur.sing 1671 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1672 
    only user who owns the transaction can view its order details.
3431 rajveer 1673 
 
94 ashish 1674 
    Parameters:
1675 
     - transactionId
1528 ankur.sing 1676 
     - customerId
94 ashish 1677 
    """
1528 ankur.sing 1678 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1679 
    return self.recv_getOrdersForTransaction()
94 ashish 1680 
 
1528 ankur.sing 1681 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1682 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1683 
    args = getOrdersForTransaction_args()
94 ashish 1684 
    args.transactionId = transactionId
1528 ankur.sing 1685 
    args.customerId = customerId
94 ashish 1686 
    args.write(self._oprot)
1687 
    self._oprot.writeMessageEnd()
1688 
    self._oprot.trans.flush()
1689 
 
483 rajveer 1690 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1691 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1692 
    if mtype == TMessageType.EXCEPTION:
1693 
      x = TApplicationException()
1694 
      x.read(self._iprot)
1695 
      self._iprot.readMessageEnd()
1696 
      raise x
483 rajveer 1697 
    result = getOrdersForTransaction_result()
94 ashish 1698 
    result.read(self._iprot)
1699 
    self._iprot.readMessageEnd()
3431 rajveer 1700 
    if result.success is not None:
94 ashish 1701 
      return result.success
3431 rajveer 1702 
    if result.ex is not None:
94 ashish 1703 
      raise result.ex
483 rajveer 1704 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1705 
 
3014 chandransh 1706 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1707 
    """
3014 chandransh 1708 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1709 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1710 
 
94 ashish 1711 
    Parameters:
483 rajveer 1712 
     - customerId
1713 
     - from_date
1714 
     - to_date
3014 chandransh 1715 
     - statuses
94 ashish 1716 
    """
3014 chandransh 1717 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1718 
    return self.recv_getOrdersForCustomer()
94 ashish 1719 
 
3014 chandransh 1720 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1721 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1722 
    args = getOrdersForCustomer_args()
1723 
    args.customerId = customerId
1724 
    args.from_date = from_date
1725 
    args.to_date = to_date
3014 chandransh 1726 
    args.statuses = statuses
94 ashish 1727 
    args.write(self._oprot)
1728 
    self._oprot.writeMessageEnd()
1729 
    self._oprot.trans.flush()
1730 
 
483 rajveer 1731 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1732 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1733 
    if mtype == TMessageType.EXCEPTION:
1734 
      x = TApplicationException()
1735 
      x.read(self._iprot)
1736 
      self._iprot.readMessageEnd()
1737 
      raise x
483 rajveer 1738 
    result = getOrdersForCustomer_result()
94 ashish 1739 
    result.read(self._iprot)
1740 
    self._iprot.readMessageEnd()
3431 rajveer 1741 
    if result.success is not None:
94 ashish 1742 
      return result.success
3431 rajveer 1743 
    if result.ex is not None:
94 ashish 1744 
      raise result.ex
483 rajveer 1745 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1746 
 
483 rajveer 1747 
  def createOrder(self, order):
94 ashish 1748 
    """
1749 
    Parameters:
483 rajveer 1750 
     - order
94 ashish 1751 
    """
483 rajveer 1752 
    self.send_createOrder(order)
1753 
    return self.recv_createOrder()
94 ashish 1754 
 
483 rajveer 1755 
  def send_createOrder(self, order):
1756 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1757 
    args = createOrder_args()
1758 
    args.order = order
94 ashish 1759 
    args.write(self._oprot)
1760 
    self._oprot.writeMessageEnd()
1761 
    self._oprot.trans.flush()
1762 
 
483 rajveer 1763 
  def recv_createOrder(self, ):
94 ashish 1764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1765 
    if mtype == TMessageType.EXCEPTION:
1766 
      x = TApplicationException()
1767 
      x.read(self._iprot)
1768 
      self._iprot.readMessageEnd()
1769 
      raise x
483 rajveer 1770 
    result = createOrder_result()
94 ashish 1771 
    result.read(self._iprot)
1772 
    self._iprot.readMessageEnd()
3431 rajveer 1773 
    if result.success is not None:
94 ashish 1774 
      return result.success
3431 rajveer 1775 
    if result.ex is not None:
94 ashish 1776 
      raise result.ex
483 rajveer 1777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1778 
 
483 rajveer 1779 
  def getOrder(self, id):
94 ashish 1780 
    """
1781 
    Parameters:
483 rajveer 1782 
     - id
94 ashish 1783 
    """
483 rajveer 1784 
    self.send_getOrder(id)
1785 
    return self.recv_getOrder()
94 ashish 1786 
 
483 rajveer 1787 
  def send_getOrder(self, id):
1788 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1789 
    args = getOrder_args()
1790 
    args.id = id
94 ashish 1791 
    args.write(self._oprot)
1792 
    self._oprot.writeMessageEnd()
1793 
    self._oprot.trans.flush()
1794 
 
483 rajveer 1795 
  def recv_getOrder(self, ):
94 ashish 1796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1797 
    if mtype == TMessageType.EXCEPTION:
1798 
      x = TApplicationException()
1799 
      x.read(self._iprot)
1800 
      self._iprot.readMessageEnd()
1801 
      raise x
483 rajveer 1802 
    result = getOrder_result()
94 ashish 1803 
    result.read(self._iprot)
1804 
    self._iprot.readMessageEnd()
3431 rajveer 1805 
    if result.success is not None:
94 ashish 1806 
      return result.success
3431 rajveer 1807 
    if result.ex is not None:
94 ashish 1808 
      raise result.ex
483 rajveer 1809 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1810 
 
483 rajveer 1811 
  def getLineItemsForOrder(self, orderId):
94 ashish 1812 
    """
1813 
    Parameters:
483 rajveer 1814 
     - orderId
94 ashish 1815 
    """
483 rajveer 1816 
    self.send_getLineItemsForOrder(orderId)
1817 
    return self.recv_getLineItemsForOrder()
94 ashish 1818 
 
483 rajveer 1819 
  def send_getLineItemsForOrder(self, orderId):
1820 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1821 
    args = getLineItemsForOrder_args()
1822 
    args.orderId = orderId
94 ashish 1823 
    args.write(self._oprot)
1824 
    self._oprot.writeMessageEnd()
1825 
    self._oprot.trans.flush()
1826 
 
483 rajveer 1827 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1828 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1829 
    if mtype == TMessageType.EXCEPTION:
1830 
      x = TApplicationException()
1831 
      x.read(self._iprot)
1832 
      self._iprot.readMessageEnd()
1833 
      raise x
483 rajveer 1834 
    result = getLineItemsForOrder_result()
94 ashish 1835 
    result.read(self._iprot)
1836 
    self._iprot.readMessageEnd()
3431 rajveer 1837 
    if result.success is not None:
94 ashish 1838 
      return result.success
3431 rajveer 1839 
    if result.ex is not None:
94 ashish 1840 
      raise result.ex
483 rajveer 1841 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1842 
 
4999 phani.kuma 1843 
  def getOrderList(self, order_ids):
1844 
    """
1845 
    Parameters:
1846 
     - order_ids
1847 
    """
1848 
    self.send_getOrderList(order_ids)
1849 
    return self.recv_getOrderList()
1850 
 
1851 
  def send_getOrderList(self, order_ids):
1852 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
1853 
    args = getOrderList_args()
1854 
    args.order_ids = order_ids
1855 
    args.write(self._oprot)
1856 
    self._oprot.writeMessageEnd()
1857 
    self._oprot.trans.flush()
1858 
 
1859 
  def recv_getOrderList(self, ):
1860 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1861 
    if mtype == TMessageType.EXCEPTION:
1862 
      x = TApplicationException()
1863 
      x.read(self._iprot)
1864 
      self._iprot.readMessageEnd()
1865 
      raise x
1866 
    result = getOrderList_result()
1867 
    result.read(self._iprot)
1868 
    self._iprot.readMessageEnd()
1869 
    if result.success is not None:
1870 
      return result.success
1871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
1872 
 
1528 ankur.sing 1873 
  def getOrderForCustomer(self, orderId, customerId):
1874 
    """
1875 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1876 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1877 
 
1528 ankur.sing 1878 
    Parameters:
1879 
     - orderId
1880 
     - customerId
1881 
    """
1882 
    self.send_getOrderForCustomer(orderId, customerId)
1883 
    return self.recv_getOrderForCustomer()
1884 
 
1885 
  def send_getOrderForCustomer(self, orderId, customerId):
1886 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1887 
    args = getOrderForCustomer_args()
1888 
    args.orderId = orderId
1889 
    args.customerId = customerId
1890 
    args.write(self._oprot)
1891 
    self._oprot.writeMessageEnd()
1892 
    self._oprot.trans.flush()
1893 
 
1894 
  def recv_getOrderForCustomer(self, ):
1895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1896 
    if mtype == TMessageType.EXCEPTION:
1897 
      x = TApplicationException()
1898 
      x.read(self._iprot)
1899 
      self._iprot.readMessageEnd()
1900 
      raise x
1901 
    result = getOrderForCustomer_result()
1902 
    result.read(self._iprot)
1903 
    self._iprot.readMessageEnd()
3431 rajveer 1904 
    if result.success is not None:
1528 ankur.sing 1905 
      return result.success
3431 rajveer 1906 
    if result.ex is not None:
1528 ankur.sing 1907 
      raise result.ex
1908 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1909 
 
4444 rajveer 1910 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1911 
    """
1912 
    Parameters:
4394 rajveer 1913 
     - type
4444 rajveer 1914 
     - warehouseId
4394 rajveer 1915 
     - status
1916 
     - timestamp
3064 chandransh 1917 
    """
4444 rajveer 1918 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1919 
    return self.recv_getAlerts()
1920 
 
4444 rajveer 1921 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1922 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1923 
    args = getAlerts_args()
4394 rajveer 1924 
    args.type = type
4444 rajveer 1925 
    args.warehouseId = warehouseId
4394 rajveer 1926 
    args.status = status
1927 
    args.timestamp = timestamp
3064 chandransh 1928 
    args.write(self._oprot)
1929 
    self._oprot.writeMessageEnd()
1930 
    self._oprot.trans.flush()
1931 
 
1932 
  def recv_getAlerts(self, ):
1933 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1934 
    if mtype == TMessageType.EXCEPTION:
1935 
      x = TApplicationException()
1936 
      x.read(self._iprot)
1937 
      self._iprot.readMessageEnd()
1938 
      raise x
1939 
    result = getAlerts_result()
1940 
    result.read(self._iprot)
1941 
    self._iprot.readMessageEnd()
3431 rajveer 1942 
    if result.success is not None:
3064 chandransh 1943 
      return result.success
1944 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1945 
 
4444 rajveer 1946 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1947 
    """
1948 
    Parameters:
1949 
     - type
4444 rajveer 1950 
     - warehouseId
4394 rajveer 1951 
     - description
3064 chandransh 1952 
    """
4444 rajveer 1953 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1954 
    self.recv_addAlert()
3064 chandransh 1955 
 
4444 rajveer 1956 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1957 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1958 
    args = addAlert_args()
3064 chandransh 1959 
    args.type = type
4444 rajveer 1960 
    args.warehouseId = warehouseId
4394 rajveer 1961 
    args.description = description
3064 chandransh 1962 
    args.write(self._oprot)
1963 
    self._oprot.writeMessageEnd()
1964 
    self._oprot.trans.flush()
1965 
 
4394 rajveer 1966 
  def recv_addAlert(self, ):
3064 chandransh 1967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1968 
    if mtype == TMessageType.EXCEPTION:
1969 
      x = TApplicationException()
1970 
      x.read(self._iprot)
1971 
      self._iprot.readMessageEnd()
1972 
      raise x
4394 rajveer 1973 
    result = addAlert_result()
3064 chandransh 1974 
    result.read(self._iprot)
1975 
    self._iprot.readMessageEnd()
1976 
    return
1977 
 
4444 rajveer 1978 
  def markAlertsAsSeen(self, warehouseId):
1979 
    """
1980 
    Parameters:
1981 
     - warehouseId
1982 
    """
1983 
    self.send_markAlertsAsSeen(warehouseId)
1984 
    self.recv_markAlertsAsSeen()
1985 
 
1986 
  def send_markAlertsAsSeen(self, warehouseId):
1987 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1988 
    args = markAlertsAsSeen_args()
1989 
    args.warehouseId = warehouseId
1990 
    args.write(self._oprot)
1991 
    self._oprot.writeMessageEnd()
1992 
    self._oprot.trans.flush()
1993 
 
1994 
  def recv_markAlertsAsSeen(self, ):
1995 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1996 
    if mtype == TMessageType.EXCEPTION:
1997 
      x = TApplicationException()
1998 
      x.read(self._iprot)
1999 
      self._iprot.readMessageEnd()
2000 
      raise x
2001 
    result = markAlertsAsSeen_result()
2002 
    result.read(self._iprot)
2003 
    self._iprot.readMessageEnd()
2004 
    return
2005 
 
3064 chandransh 2006 
  def getValidOrderCount(self, ):
2007 
    """
2008 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2009 
    """
2010 
    self.send_getValidOrderCount()
2011 
    return self.recv_getValidOrderCount()
2012 
 
2013 
  def send_getValidOrderCount(self, ):
2014 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2015 
    args = getValidOrderCount_args()
2016 
    args.write(self._oprot)
2017 
    self._oprot.writeMessageEnd()
2018 
    self._oprot.trans.flush()
2019 
 
2020 
  def recv_getValidOrderCount(self, ):
2021 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2022 
    if mtype == TMessageType.EXCEPTION:
2023 
      x = TApplicationException()
2024 
      x.read(self._iprot)
2025 
      self._iprot.readMessageEnd()
2026 
      raise x
2027 
    result = getValidOrderCount_result()
2028 
    result.read(self._iprot)
2029 
    self._iprot.readMessageEnd()
3431 rajveer 2030 
    if result.success is not None:
3064 chandransh 2031 
      return result.success
2032 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2033 
 
2034 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2035 
    """
2036 
    Returns the number of distinct customers who have done successful transactions
2037 
    """
2038 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2039 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2040 
 
2041 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2042 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2043 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2044 
    args.write(self._oprot)
2045 
    self._oprot.writeMessageEnd()
2046 
    self._oprot.trans.flush()
2047 
 
2048 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2049 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2050 
    if mtype == TMessageType.EXCEPTION:
2051 
      x = TApplicationException()
2052 
      x.read(self._iprot)
2053 
      self._iprot.readMessageEnd()
2054 
      raise x
2055 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2056 
    result.read(self._iprot)
2057 
    self._iprot.readMessageEnd()
3431 rajveer 2058 
    if result.success is not None:
3064 chandransh 2059 
      return result.success
2060 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2061 
 
2062 
  def getValidOrdersAmountRange(self, ):
2063 
    """
2064 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2065 
    List contains two values, first minimum amount and second maximum amount.
2066 
    """
2067 
    self.send_getValidOrdersAmountRange()
2068 
    return self.recv_getValidOrdersAmountRange()
2069 
 
2070 
  def send_getValidOrdersAmountRange(self, ):
2071 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2072 
    args = getValidOrdersAmountRange_args()
2073 
    args.write(self._oprot)
2074 
    self._oprot.writeMessageEnd()
2075 
    self._oprot.trans.flush()
2076 
 
2077 
  def recv_getValidOrdersAmountRange(self, ):
2078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2079 
    if mtype == TMessageType.EXCEPTION:
2080 
      x = TApplicationException()
2081 
      x.read(self._iprot)
2082 
      self._iprot.readMessageEnd()
2083 
      raise x
2084 
    result = getValidOrdersAmountRange_result()
2085 
    result.read(self._iprot)
2086 
    self._iprot.readMessageEnd()
3431 rajveer 2087 
    if result.success is not None:
3064 chandransh 2088 
      return result.success
2089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2090 
 
2091 
  def getValidOrders(self, limit):
2092 
    """
2093 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2094 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2095 
 
3064 chandransh 2096 
    Parameters:
2097 
     - limit
2098 
    """
2099 
    self.send_getValidOrders(limit)
2100 
    return self.recv_getValidOrders()
2101 
 
2102 
  def send_getValidOrders(self, limit):
2103 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2104 
    args = getValidOrders_args()
2105 
    args.limit = limit
2106 
    args.write(self._oprot)
2107 
    self._oprot.writeMessageEnd()
2108 
    self._oprot.trans.flush()
2109 
 
2110 
  def recv_getValidOrders(self, ):
2111 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2112 
    if mtype == TMessageType.EXCEPTION:
2113 
      x = TApplicationException()
2114 
      x.read(self._iprot)
2115 
      self._iprot.readMessageEnd()
2116 
      raise x
2117 
    result = getValidOrders_result()
2118 
    result.read(self._iprot)
2119 
    self._iprot.readMessageEnd()
3431 rajveer 2120 
    if result.success is not None:
3064 chandransh 2121 
      return result.success
2122 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2123 
 
1220 chandransh 2124 
  def batchOrders(self, warehouseId):
2125 
    """
2126 
    Create a batch of all the pending orders for the given warehouse.
2127 
    The returned list is orderd by created_timestamp.
2128 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2129 
 
1220 chandransh 2130 
    Parameters:
2131 
     - warehouseId
2132 
    """
2133 
    self.send_batchOrders(warehouseId)
2134 
    return self.recv_batchOrders()
2135 
 
2136 
  def send_batchOrders(self, warehouseId):
2137 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2138 
    args = batchOrders_args()
2139 
    args.warehouseId = warehouseId
2140 
    args.write(self._oprot)
2141 
    self._oprot.writeMessageEnd()
2142 
    self._oprot.trans.flush()
2143 
 
2144 
  def recv_batchOrders(self, ):
2145 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2146 
    if mtype == TMessageType.EXCEPTION:
2147 
      x = TApplicationException()
2148 
      x.read(self._iprot)
2149 
      self._iprot.readMessageEnd()
2150 
      raise x
2151 
    result = batchOrders_result()
2152 
    result.read(self._iprot)
2153 
    self._iprot.readMessageEnd()
3431 rajveer 2154 
    if result.success is not None:
1220 chandransh 2155 
      return result.success
3431 rajveer 2156 
    if result.ex is not None:
1220 chandransh 2157 
      raise result.ex
2158 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2159 
 
1208 chandransh 2160 
  def markOrderAsOutOfStock(self, orderId):
2161 
    """
2162 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2163 
 
1208 chandransh 2164 
    Parameters:
2165 
     - orderId
2166 
    """
2167 
    self.send_markOrderAsOutOfStock(orderId)
2168 
    return self.recv_markOrderAsOutOfStock()
2169 
 
2170 
  def send_markOrderAsOutOfStock(self, orderId):
2171 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2172 
    args = markOrderAsOutOfStock_args()
2173 
    args.orderId = orderId
2174 
    args.write(self._oprot)
2175 
    self._oprot.writeMessageEnd()
2176 
    self._oprot.trans.flush()
2177 
 
2178 
  def recv_markOrderAsOutOfStock(self, ):
2179 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2180 
    if mtype == TMessageType.EXCEPTION:
2181 
      x = TApplicationException()
2182 
      x.read(self._iprot)
2183 
      self._iprot.readMessageEnd()
2184 
      raise x
2185 
    result = markOrderAsOutOfStock_result()
2186 
    result.read(self._iprot)
2187 
    self._iprot.readMessageEnd()
3431 rajveer 2188 
    if result.success is not None:
1208 chandransh 2189 
      return result.success
3431 rajveer 2190 
    if result.ex is not None:
1208 chandransh 2191 
      raise result.ex
2192 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2193 
 
3064 chandransh 2194 
  def verifyOrder(self, orderId):
759 chandransh 2195 
    """
3064 chandransh 2196 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2197 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2198 
    used for all other orders as well.
2199 
    Throws an exception if no such order exists.
3431 rajveer 2200 
 
759 chandransh 2201 
    Parameters:
3064 chandransh 2202 
     - orderId
759 chandransh 2203 
    """
3064 chandransh 2204 
    self.send_verifyOrder(orderId)
2205 
    return self.recv_verifyOrder()
759 chandransh 2206 
 
3064 chandransh 2207 
  def send_verifyOrder(self, orderId):
2208 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2209 
    args = verifyOrder_args()
2210 
    args.orderId = orderId
759 chandransh 2211 
    args.write(self._oprot)
2212 
    self._oprot.writeMessageEnd()
2213 
    self._oprot.trans.flush()
2214 
 
3064 chandransh 2215 
  def recv_verifyOrder(self, ):
759 chandransh 2216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2217 
    if mtype == TMessageType.EXCEPTION:
2218 
      x = TApplicationException()
2219 
      x.read(self._iprot)
2220 
      self._iprot.readMessageEnd()
2221 
      raise x
3064 chandransh 2222 
    result = verifyOrder_result()
759 chandransh 2223 
    result.read(self._iprot)
2224 
    self._iprot.readMessageEnd()
3431 rajveer 2225 
    if result.success is not None:
759 chandransh 2226 
      return result.success
3431 rajveer 2227 
    if result.ex is not None:
759 chandransh 2228 
      raise result.ex
3064 chandransh 2229 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2230 
 
3064 chandransh 2231 
  def acceptOrder(self, orderId):
1113 chandransh 2232 
    """
3064 chandransh 2233 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2234 
    given order is not a COD order, it also captures the payment if the same has
2235 
    not been captured.
2236 
    Throws an exception if no such order exists.
3431 rajveer 2237 
 
1113 chandransh 2238 
    Parameters:
3064 chandransh 2239 
     - orderId
1113 chandransh 2240 
    """
3064 chandransh 2241 
    self.send_acceptOrder(orderId)
2242 
    return self.recv_acceptOrder()
1113 chandransh 2243 
 
3064 chandransh 2244 
  def send_acceptOrder(self, orderId):
2245 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2246 
    args = acceptOrder_args()
2247 
    args.orderId = orderId
1113 chandransh 2248 
    args.write(self._oprot)
2249 
    self._oprot.writeMessageEnd()
2250 
    self._oprot.trans.flush()
2251 
 
3064 chandransh 2252 
  def recv_acceptOrder(self, ):
1113 chandransh 2253 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2254 
    if mtype == TMessageType.EXCEPTION:
2255 
      x = TApplicationException()
2256 
      x.read(self._iprot)
2257 
      self._iprot.readMessageEnd()
2258 
      raise x
3064 chandransh 2259 
    result = acceptOrder_result()
1113 chandransh 2260 
    result.read(self._iprot)
2261 
    self._iprot.readMessageEnd()
3431 rajveer 2262 
    if result.success is not None:
1113 chandransh 2263 
      return result.success
3431 rajveer 2264 
    if result.ex is not None:
1113 chandransh 2265 
      raise result.ex
3064 chandransh 2266 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2267 
 
5110 mandeep.dh 2268 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2269 
    """
3064 chandransh 2270 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2271 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2272 
    the IMEI no. if a -1 is supplied.
2273 
    Also, it generates an invoice number for the order, marks the order as
2274 
    BILLED and sets the billing timestamp.
2275 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2276 
 
1135 chandransh 2277 
    Parameters:
3064 chandransh 2278 
     - orderId
2279 
     - invoice_number
4658 mandeep.dh 2280 
     - serialNumber
4283 anupam.sin 2281 
     - itemNumber
3064 chandransh 2282 
     - billed_by
4264 rajveer 2283 
     - jacketNumber
4283 anupam.sin 2284 
     - billingType
5110 mandeep.dh 2285 
     - fulfilmentWarehouseId
4763 rajveer 2286 
     - authorize
1135 chandransh 2287 
    """
5110 mandeep.dh 2288 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2289 
    return self.recv_addBillingDetails()
1135 chandransh 2290 
 
5110 mandeep.dh 2291 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2292 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2293 
    args = addBillingDetails_args()
2294 
    args.orderId = orderId
2295 
    args.invoice_number = invoice_number
4658 mandeep.dh 2296 
    args.serialNumber = serialNumber
4283 anupam.sin 2297 
    args.itemNumber = itemNumber
3064 chandransh 2298 
    args.billed_by = billed_by
4264 rajveer 2299 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2300 
    args.billingType = billingType
5110 mandeep.dh 2301 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2302 
    args.authorize = authorize
1135 chandransh 2303 
    args.write(self._oprot)
2304 
    self._oprot.writeMessageEnd()
2305 
    self._oprot.trans.flush()
2306 
 
3064 chandransh 2307 
  def recv_addBillingDetails(self, ):
1135 chandransh 2308 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2309 
    if mtype == TMessageType.EXCEPTION:
2310 
      x = TApplicationException()
2311 
      x.read(self._iprot)
2312 
      self._iprot.readMessageEnd()
2313 
      raise x
3064 chandransh 2314 
    result = addBillingDetails_result()
1135 chandransh 2315 
    result.read(self._iprot)
2316 
    self._iprot.readMessageEnd()
3431 rajveer 2317 
    if result.success is not None:
3064 chandransh 2318 
      return result.success
3431 rajveer 2319 
    if result.ex is not None:
1135 chandransh 2320 
      raise result.ex
3064 chandransh 2321 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2322 
 
4763 rajveer 2323 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2324 
    """
2325 
    Add the invoice number to the order.
2326 
 
2327 
    Parameters:
2328 
     - orderId
2329 
     - invoiceNumber
4763 rajveer 2330 
     - color
4579 rajveer 2331 
    """
4763 rajveer 2332 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2333 
    self.recv_addInvoiceNumber()
2334 
 
4763 rajveer 2335 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2336 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2337 
    args = addInvoiceNumber_args()
2338 
    args.orderId = orderId
2339 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2340 
    args.color = color
4579 rajveer 2341 
    args.write(self._oprot)
2342 
    self._oprot.writeMessageEnd()
2343 
    self._oprot.trans.flush()
2344 
 
2345 
  def recv_addInvoiceNumber(self, ):
2346 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2347 
    if mtype == TMessageType.EXCEPTION:
2348 
      x = TApplicationException()
2349 
      x.read(self._iprot)
2350 
      self._iprot.readMessageEnd()
2351 
      raise x
2352 
    result = addInvoiceNumber_result()
2353 
    result.read(self._iprot)
2354 
    self._iprot.readMessageEnd()
2355 
    if result.ex is not None:
2356 
      raise result.ex
2357 
    return
2358 
 
4910 phani.kuma 2359 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2360 
    """
3064 chandransh 2361 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2362 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2363 
 
1408 ankur.sing 2364 
    Parameters:
3064 chandransh 2365 
     - warehouseId
1408 ankur.sing 2366 
     - providerId
3064 chandransh 2367 
     - cod
4910 phani.kuma 2368 
     - orderIds
1408 ankur.sing 2369 
    """
4910 phani.kuma 2370 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2371 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2372 
 
4910 phani.kuma 2373 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2374 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2375 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2376 
    args.warehouseId = warehouseId
1408 ankur.sing 2377 
    args.providerId = providerId
3064 chandransh 2378 
    args.cod = cod
4910 phani.kuma 2379 
    args.orderIds = orderIds
1408 ankur.sing 2380 
    args.write(self._oprot)
2381 
    self._oprot.writeMessageEnd()
2382 
    self._oprot.trans.flush()
2383 
 
4910 phani.kuma 2384 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2385 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2386 
    if mtype == TMessageType.EXCEPTION:
2387 
      x = TApplicationException()
2388 
      x.read(self._iprot)
2389 
      self._iprot.readMessageEnd()
2390 
      raise x
4910 phani.kuma 2391 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2392 
    result.read(self._iprot)
2393 
    self._iprot.readMessageEnd()
3431 rajveer 2394 
    if result.success is not None:
1408 ankur.sing 2395 
      return result.success
3431 rajveer 2396 
    if result.ex is not None:
3064 chandransh 2397 
      raise result.ex
4910 phani.kuma 2398 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2399 
 
4910 phani.kuma 2400 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2401 
    """
4910 phani.kuma 2402 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2403 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2404 
 
2405 
    Parameters:
2406 
     - providerId
4910 phani.kuma 2407 
     - pickupDetails
4410 rajveer 2408 
    """
4910 phani.kuma 2409 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2410 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2411 
 
4910 phani.kuma 2412 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2413 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2414 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2415 
    args.providerId = providerId
4910 phani.kuma 2416 
    args.pickupDetails = pickupDetails
4410 rajveer 2417 
    args.write(self._oprot)
2418 
    self._oprot.writeMessageEnd()
2419 
    self._oprot.trans.flush()
2420 
 
4910 phani.kuma 2421 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2422 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2423 
    if mtype == TMessageType.EXCEPTION:
2424 
      x = TApplicationException()
2425 
      x.read(self._iprot)
2426 
      self._iprot.readMessageEnd()
2427 
      raise x
4910 phani.kuma 2428 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2429 
    result.read(self._iprot)
2430 
    self._iprot.readMessageEnd()
2431 
    if result.ex is not None:
2432 
      raise result.ex
4910 phani.kuma 2433 
    return
4410 rajveer 2434 
 
4910 phani.kuma 2435 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2436 
    """
3064 chandransh 2437 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2438 
 
94 ashish 2439 
    Parameters:
3064 chandransh 2440 
     - providerId
304 ashish 2441 
    """
4910 phani.kuma 2442 
    self.send_getOrdersNotPickedUp(providerId)
2443 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2444 
 
4910 phani.kuma 2445 
  def send_getOrdersNotPickedUp(self, providerId):
2446 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2447 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2448 
    args.providerId = providerId
304 ashish 2449 
    args.write(self._oprot)
2450 
    self._oprot.writeMessageEnd()
2451 
    self._oprot.trans.flush()
2452 
 
4910 phani.kuma 2453 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2454 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2455 
    if mtype == TMessageType.EXCEPTION:
2456 
      x = TApplicationException()
2457 
      x.read(self._iprot)
2458 
      self._iprot.readMessageEnd()
2459 
      raise x
4910 phani.kuma 2460 
    result = getOrdersNotPickedUp_result()
304 ashish 2461 
    result.read(self._iprot)
2462 
    self._iprot.readMessageEnd()
3431 rajveer 2463 
    if result.success is not None:
304 ashish 2464 
      return result.success
4910 phani.kuma 2465 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2466 
 
3064 chandransh 2467 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2468 
    """
3064 chandransh 2469 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2470 
    the name of the receiver.
2471 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2472 
 
304 ashish 2473 
    Parameters:
3064 chandransh 2474 
     - providerId
2475 
     - deliveredOrders
304 ashish 2476 
    """
3064 chandransh 2477 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2478 
    self.recv_markOrdersAsDelivered()
304 ashish 2479 
 
3064 chandransh 2480 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2481 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2482 
    args = markOrdersAsDelivered_args()
2483 
    args.providerId = providerId
2484 
    args.deliveredOrders = deliveredOrders
304 ashish 2485 
    args.write(self._oprot)
2486 
    self._oprot.writeMessageEnd()
2487 
    self._oprot.trans.flush()
2488 
 
3064 chandransh 2489 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2490 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2491 
    if mtype == TMessageType.EXCEPTION:
2492 
      x = TApplicationException()
2493 
      x.read(self._iprot)
2494 
      self._iprot.readMessageEnd()
2495 
      raise x
3064 chandransh 2496 
    result = markOrdersAsDelivered_result()
304 ashish 2497 
    result.read(self._iprot)
2498 
    self._iprot.readMessageEnd()
3431 rajveer 2499 
    if result.ex is not None:
3064 chandransh 2500 
      raise result.ex
304 ashish 2501 
    return
2502 
 
4910 phani.kuma 2503 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2504 
    """
4910 phani.kuma 2505 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2506 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2507 
 
3064 chandransh 2508 
    Parameters:
2509 
     - providerId
2510 
     - returnedOrders
1596 ankur.sing 2511 
    """
4910 phani.kuma 2512 
    self.send_markAsRTOrders(providerId, returnedOrders)
2513 
    self.recv_markAsRTOrders()
304 ashish 2514 
 
4910 phani.kuma 2515 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2516 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2517 
    args = markAsRTOrders_args()
3064 chandransh 2518 
    args.providerId = providerId
2519 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2520 
    args.write(self._oprot)
2521 
    self._oprot.writeMessageEnd()
2522 
    self._oprot.trans.flush()
2523 
 
4910 phani.kuma 2524 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2525 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2526 
    if mtype == TMessageType.EXCEPTION:
2527 
      x = TApplicationException()
2528 
      x.read(self._iprot)
2529 
      self._iprot.readMessageEnd()
2530 
      raise x
4910 phani.kuma 2531 
    result = markAsRTOrders_result()
1596 ankur.sing 2532 
    result.read(self._iprot)
2533 
    self._iprot.readMessageEnd()
3431 rajveer 2534 
    if result.ex is not None:
3064 chandransh 2535 
      raise result.ex
2536 
    return
1596 ankur.sing 2537 
 
4910 phani.kuma 2538 
  def getRTOrders(self, providerId):
2539 
    """
2540 
    Returns a list of orders that were returned by courier.
2541 
 
2542 
    Parameters:
2543 
     - providerId
2544 
    """
2545 
    self.send_getRTOrders(providerId)
2546 
    return self.recv_getRTOrders()
2547 
 
2548 
  def send_getRTOrders(self, providerId):
2549 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2550 
    args = getRTOrders_args()
2551 
    args.providerId = providerId
2552 
    args.write(self._oprot)
2553 
    self._oprot.writeMessageEnd()
2554 
    self._oprot.trans.flush()
2555 
 
2556 
  def recv_getRTOrders(self, ):
2557 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2558 
    if mtype == TMessageType.EXCEPTION:
2559 
      x = TApplicationException()
2560 
      x.read(self._iprot)
2561 
      self._iprot.readMessageEnd()
2562 
      raise x
2563 
    result = getRTOrders_result()
2564 
    result.read(self._iprot)
2565 
    self._iprot.readMessageEnd()
2566 
    if result.success is not None:
2567 
      return result.success
2568 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2569 
 
3064 chandransh 2570 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2571 
    """
3064 chandransh 2572 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2573 
 
3064 chandransh 2574 
    Parameters:
2575 
     - providerId
2576 
     - undeliveredOrders
1627 ankur.sing 2577 
    """
3064 chandransh 2578 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2579 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2580 
 
3064 chandransh 2581 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2582 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2583 
    args = updateNonDeliveryReason_args()
2584 
    args.providerId = providerId
2585 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2586 
    args.write(self._oprot)
2587 
    self._oprot.writeMessageEnd()
2588 
    self._oprot.trans.flush()
2589 
 
3064 chandransh 2590 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2591 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2592 
    if mtype == TMessageType.EXCEPTION:
2593 
      x = TApplicationException()
2594 
      x.read(self._iprot)
2595 
      self._iprot.readMessageEnd()
2596 
      raise x
3064 chandransh 2597 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2598 
    result.read(self._iprot)
2599 
    self._iprot.readMessageEnd()
4910 phani.kuma 2600 
    if result.ex is not None:
2601 
      raise result.ex
2602 
    return
2603 
 
2604 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2605 
    """
2606 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2607 
 
2608 
    Parameters:
2609 
     - providerId
2610 
    """
2611 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2612 
    return self.recv_getNonDeliveredOrdersbyCourier()
2613 
 
2614 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2615 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2616 
    args = getNonDeliveredOrdersbyCourier_args()
2617 
    args.providerId = providerId
2618 
    args.write(self._oprot)
2619 
    self._oprot.writeMessageEnd()
2620 
    self._oprot.trans.flush()
2621 
 
2622 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2623 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2624 
    if mtype == TMessageType.EXCEPTION:
2625 
      x = TApplicationException()
2626 
      x.read(self._iprot)
2627 
      self._iprot.readMessageEnd()
2628 
      raise x
2629 
    result = getNonDeliveredOrdersbyCourier_result()
2630 
    result.read(self._iprot)
2631 
    self._iprot.readMessageEnd()
4581 phani.kuma 2632 
    if result.success is not None:
2633 
      return result.success
4910 phani.kuma 2634 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2635 
 
2636 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2637 
    """
2638 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2639 
 
2640 
    Parameters:
2641 
     - providerId
2642 
     - local_connected_orders
2643 
    """
2644 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2645 
    self.recv_markOrdersAsLocalConnected()
2646 
 
2647 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2648 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2649 
    args = markOrdersAsLocalConnected_args()
2650 
    args.providerId = providerId
2651 
    args.local_connected_orders = local_connected_orders
2652 
    args.write(self._oprot)
2653 
    self._oprot.writeMessageEnd()
2654 
    self._oprot.trans.flush()
2655 
 
2656 
  def recv_markOrdersAsLocalConnected(self, ):
2657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2658 
    if mtype == TMessageType.EXCEPTION:
2659 
      x = TApplicationException()
2660 
      x.read(self._iprot)
2661 
      self._iprot.readMessageEnd()
2662 
      raise x
2663 
    result = markOrdersAsLocalConnected_result()
2664 
    result.read(self._iprot)
2665 
    self._iprot.readMessageEnd()
3431 rajveer 2666 
    if result.ex is not None:
3064 chandransh 2667 
      raise result.ex
4910 phani.kuma 2668 
    return
1627 ankur.sing 2669 
 
4910 phani.kuma 2670 
  def getOrdersNotLocalConnected(self, providerId):
2671 
    """
2672 
    Returns a list of orders that were picked up or shipped but pending local connection.
2673 
 
2674 
    Parameters:
2675 
     - providerId
2676 
    """
2677 
    self.send_getOrdersNotLocalConnected(providerId)
2678 
    return self.recv_getOrdersNotLocalConnected()
2679 
 
2680 
  def send_getOrdersNotLocalConnected(self, providerId):
2681 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2682 
    args = getOrdersNotLocalConnected_args()
2683 
    args.providerId = providerId
2684 
    args.write(self._oprot)
2685 
    self._oprot.writeMessageEnd()
2686 
    self._oprot.trans.flush()
2687 
 
2688 
  def recv_getOrdersNotLocalConnected(self, ):
2689 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2690 
    if mtype == TMessageType.EXCEPTION:
2691 
      x = TApplicationException()
2692 
      x.read(self._iprot)
2693 
      self._iprot.readMessageEnd()
2694 
      raise x
2695 
    result = getOrdersNotLocalConnected_result()
2696 
    result.read(self._iprot)
2697 
    self._iprot.readMessageEnd()
2698 
    if result.success is not None:
2699 
      return result.success
2700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2701 
 
2702 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2703 
    """
2704 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2705 
 
2706 
    Parameters:
2707 
     - providerId
2708 
     - destination_city_reached_orders
2709 
    """
2710 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2711 
    self.recv_markOrdersAsDestinationCityReached()
2712 
 
2713 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2714 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2715 
    args = markOrdersAsDestinationCityReached_args()
2716 
    args.providerId = providerId
2717 
    args.destination_city_reached_orders = destination_city_reached_orders
2718 
    args.write(self._oprot)
2719 
    self._oprot.writeMessageEnd()
2720 
    self._oprot.trans.flush()
2721 
 
2722 
  def recv_markOrdersAsDestinationCityReached(self, ):
2723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2724 
    if mtype == TMessageType.EXCEPTION:
2725 
      x = TApplicationException()
2726 
      x.read(self._iprot)
2727 
      self._iprot.readMessageEnd()
2728 
      raise x
2729 
    result = markOrdersAsDestinationCityReached_result()
2730 
    result.read(self._iprot)
2731 
    self._iprot.readMessageEnd()
2732 
    if result.ex is not None:
2733 
      raise result.ex
2734 
    return
2735 
 
2736 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2737 
    """
2738 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
2739 
 
2740 
    Parameters:
2741 
     - providerId
2742 
     - first_atdl_orders
2743 
    """
2744 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
2745 
    self.recv_markOrdersAsFirstDeliveryAttempted()
2746 
 
2747 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2748 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
2749 
    args = markOrdersAsFirstDeliveryAttempted_args()
2750 
    args.providerId = providerId
2751 
    args.first_atdl_orders = first_atdl_orders
2752 
    args.write(self._oprot)
2753 
    self._oprot.writeMessageEnd()
2754 
    self._oprot.trans.flush()
2755 
 
2756 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
2757 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2758 
    if mtype == TMessageType.EXCEPTION:
2759 
      x = TApplicationException()
2760 
      x.read(self._iprot)
2761 
      self._iprot.readMessageEnd()
2762 
      raise x
2763 
    result = markOrdersAsFirstDeliveryAttempted_result()
2764 
    result.read(self._iprot)
2765 
    self._iprot.readMessageEnd()
2766 
    if result.ex is not None:
2767 
      raise result.ex
2768 
    return
2769 
 
3064 chandransh 2770 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2771 
    """
3064 chandransh 2772 
    Returns the list of orders whose delivery time has passed but have not been
2773 
    delivered yet for the given provider and warehouse. To get a complete list of
2774 
    undelivered orders, pass them as -1.
2775 
    Returns an empty list if no such orders exist.
3431 rajveer 2776 
 
1886 ankur.sing 2777 
    Parameters:
3064 chandransh 2778 
     - providerId
2779 
     - warehouseId
1886 ankur.sing 2780 
    """
3064 chandransh 2781 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2782 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2783 
 
3064 chandransh 2784 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2785 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2786 
    args = getUndeliveredOrders_args()
2787 
    args.providerId = providerId
2788 
    args.warehouseId = warehouseId
1886 ankur.sing 2789 
    args.write(self._oprot)
2790 
    self._oprot.writeMessageEnd()
2791 
    self._oprot.trans.flush()
2792 
 
3064 chandransh 2793 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2794 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2795 
    if mtype == TMessageType.EXCEPTION:
2796 
      x = TApplicationException()
2797 
      x.read(self._iprot)
2798 
      self._iprot.readMessageEnd()
2799 
      raise x
3064 chandransh 2800 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2801 
    result.read(self._iprot)
2802 
    self._iprot.readMessageEnd()
3431 rajveer 2803 
    if result.success is not None:
1886 ankur.sing 2804 
      return result.success
3064 chandransh 2805 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2806 
 
4783 phani.kuma 2807 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2808 
    """
2809 
    Returns the list of orders whose expected delivery date has passed but have not been
2810 
    delivered yet.
2811 
    Returns an empty list if no such orders exist.
2812 
    """
2813 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2814 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2815 
 
2816 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2817 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2818 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2819 
    args.write(self._oprot)
2820 
    self._oprot.writeMessageEnd()
2821 
    self._oprot.trans.flush()
2822 
 
2823 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2824 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2825 
    if mtype == TMessageType.EXCEPTION:
2826 
      x = TApplicationException()
2827 
      x.read(self._iprot)
2828 
      self._iprot.readMessageEnd()
2829 
      raise x
2830 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2831 
    result.read(self._iprot)
2832 
    self._iprot.readMessageEnd()
2833 
    if result.success is not None:
2834 
      return result.success
2835 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2836 
 
2536 chandransh 2837 
  def toggleDOAFlag(self, orderId):
2838 
    """
2839 
    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.
2840 
    Returns the final flag status.
2841 
    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 2842 
 
2536 chandransh 2843 
    Parameters:
2844 
     - orderId
2845 
    """
2846 
    self.send_toggleDOAFlag(orderId)
2847 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2848 
 
2536 chandransh 2849 
  def send_toggleDOAFlag(self, orderId):
2850 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2851 
    args = toggleDOAFlag_args()
2852 
    args.orderId = orderId
2853 
    args.write(self._oprot)
2854 
    self._oprot.writeMessageEnd()
2855 
    self._oprot.trans.flush()
2856 
 
2857 
  def recv_toggleDOAFlag(self, ):
2858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2859 
    if mtype == TMessageType.EXCEPTION:
2860 
      x = TApplicationException()
2861 
      x.read(self._iprot)
2862 
      self._iprot.readMessageEnd()
2863 
      raise x
2864 
    result = toggleDOAFlag_result()
2865 
    result.read(self._iprot)
2866 
    self._iprot.readMessageEnd()
3431 rajveer 2867 
    if result.success is not None:
2536 chandransh 2868 
      return result.success
3431 rajveer 2869 
    if result.ex is not None:
2536 chandransh 2870 
      raise result.ex
2871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2872 
 
4712 rajveer 2873 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2874 
    """
2875 
    Parameters:
2876 
     - orderId
2877 
     - deliveryTimestamp
2878 
     - receiver
2879 
    """
2880 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2881 
    self.recv_markOrderAsDelivered()
2882 
 
2883 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2884 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2885 
    args = markOrderAsDelivered_args()
2886 
    args.orderId = orderId
2887 
    args.deliveryTimestamp = deliveryTimestamp
2888 
    args.receiver = receiver
2889 
    args.write(self._oprot)
2890 
    self._oprot.writeMessageEnd()
2891 
    self._oprot.trans.flush()
2892 
 
2893 
  def recv_markOrderAsDelivered(self, ):
2894 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2895 
    if mtype == TMessageType.EXCEPTION:
2896 
      x = TApplicationException()
2897 
      x.read(self._iprot)
2898 
      self._iprot.readMessageEnd()
2899 
      raise x
2900 
    result = markOrderAsDelivered_result()
2901 
    result.read(self._iprot)
2902 
    self._iprot.readMessageEnd()
2903 
    if result.ex is not None:
2904 
      raise result.ex
2905 
    return
2906 
 
4454 rajveer 2907 
  def markOrderDoaRequestReceived(self, orderId):
2908 
    """
2909 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2910 
 
2911 
    Parameters:
2912 
     - orderId
2913 
    """
2914 
    self.send_markOrderDoaRequestReceived(orderId)
2915 
    return self.recv_markOrderDoaRequestReceived()
2916 
 
2917 
  def send_markOrderDoaRequestReceived(self, orderId):
2918 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2919 
    args = markOrderDoaRequestReceived_args()
2920 
    args.orderId = orderId
2921 
    args.write(self._oprot)
2922 
    self._oprot.writeMessageEnd()
2923 
    self._oprot.trans.flush()
2924 
 
2925 
  def recv_markOrderDoaRequestReceived(self, ):
2926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2927 
    if mtype == TMessageType.EXCEPTION:
2928 
      x = TApplicationException()
2929 
      x.read(self._iprot)
2930 
      self._iprot.readMessageEnd()
2931 
      raise x
2932 
    result = markOrderDoaRequestReceived_result()
2933 
    result.read(self._iprot)
2934 
    self._iprot.readMessageEnd()
2935 
    if result.success is not None:
2936 
      return result.success
2937 
    if result.ex is not None:
2938 
      raise result.ex
2939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2940 
 
2941 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2942 
    """
2943 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2944 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2945 
 
2946 
    Parameters:
2947 
     - orderId
2948 
     - isAuthorized
2949 
    """
2950 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2951 
    return self.recv_markOrderDoaRequestAuthorized()
2952 
 
2953 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2954 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2955 
    args = markOrderDoaRequestAuthorized_args()
2956 
    args.orderId = orderId
2957 
    args.isAuthorized = isAuthorized
2958 
    args.write(self._oprot)
2959 
    self._oprot.writeMessageEnd()
2960 
    self._oprot.trans.flush()
2961 
 
2962 
  def recv_markOrderDoaRequestAuthorized(self, ):
2963 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2964 
    if mtype == TMessageType.EXCEPTION:
2965 
      x = TApplicationException()
2966 
      x.read(self._iprot)
2967 
      self._iprot.readMessageEnd()
2968 
      raise x
2969 
    result = markOrderDoaRequestAuthorized_result()
2970 
    result.read(self._iprot)
2971 
    self._iprot.readMessageEnd()
2972 
    if result.success is not None:
2973 
      return result.success
2974 
    if result.ex is not None:
2975 
      raise result.ex
2976 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2977 
 
4488 rajveer 2978 
  def markOrderReturnRequestReceived(self, orderId):
2979 
    """
2980 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2981 
 
2982 
    Parameters:
2983 
     - orderId
2984 
    """
2985 
    self.send_markOrderReturnRequestReceived(orderId)
2986 
    return self.recv_markOrderReturnRequestReceived()
2987 
 
2988 
  def send_markOrderReturnRequestReceived(self, orderId):
2989 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2990 
    args = markOrderReturnRequestReceived_args()
2991 
    args.orderId = orderId
2992 
    args.write(self._oprot)
2993 
    self._oprot.writeMessageEnd()
2994 
    self._oprot.trans.flush()
2995 
 
2996 
  def recv_markOrderReturnRequestReceived(self, ):
2997 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2998 
    if mtype == TMessageType.EXCEPTION:
2999 
      x = TApplicationException()
3000 
      x.read(self._iprot)
3001 
      self._iprot.readMessageEnd()
3002 
      raise x
3003 
    result = markOrderReturnRequestReceived_result()
3004 
    result.read(self._iprot)
3005 
    self._iprot.readMessageEnd()
3006 
    if result.success is not None:
3007 
      return result.success
3008 
    if result.ex is not None:
3009 
      raise result.ex
3010 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3011 
 
3012 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3013 
    """
3014 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3015 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3016 
 
3017 
    Parameters:
3018 
     - orderId
3019 
     - isAuthorized
3020 
    """
3021 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3022 
    return self.recv_markOrderReturnRequestAuthorized()
3023 
 
3024 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3025 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3026 
    args = markOrderReturnRequestAuthorized_args()
3027 
    args.orderId = orderId
3028 
    args.isAuthorized = isAuthorized
3029 
    args.write(self._oprot)
3030 
    self._oprot.writeMessageEnd()
3031 
    self._oprot.trans.flush()
3032 
 
3033 
  def recv_markOrderReturnRequestAuthorized(self, ):
3034 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3035 
    if mtype == TMessageType.EXCEPTION:
3036 
      x = TApplicationException()
3037 
      x.read(self._iprot)
3038 
      self._iprot.readMessageEnd()
3039 
      raise x
3040 
    result = markOrderReturnRequestAuthorized_result()
3041 
    result.read(self._iprot)
3042 
    self._iprot.readMessageEnd()
3043 
    if result.success is not None:
3044 
      return result.success
3045 
    if result.ex is not None:
3046 
      raise result.ex
3047 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3048 
 
4579 rajveer 3049 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3050 
    """
3051 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3052 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3053 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3054 
    For any other status, it returns false.
3055 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3056 
 
2536 chandransh 3057 
    Parameters:
3058 
     - orderId
4579 rajveer 3059 
     - providerId
2536 chandransh 3060 
    """
4579 rajveer 3061 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3062 
    return self.recv_requestPickupNumber()
3063 
 
4579 rajveer 3064 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3065 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3066 
    args = requestPickupNumber_args()
3067 
    args.orderId = orderId
4579 rajveer 3068 
    args.providerId = providerId
2536 chandransh 3069 
    args.write(self._oprot)
3070 
    self._oprot.writeMessageEnd()
3071 
    self._oprot.trans.flush()
3072 
 
3073 
  def recv_requestPickupNumber(self, ):
3074 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3075 
    if mtype == TMessageType.EXCEPTION:
3076 
      x = TApplicationException()
3077 
      x.read(self._iprot)
3078 
      self._iprot.readMessageEnd()
3079 
      raise x
3080 
    result = requestPickupNumber_result()
3081 
    result.read(self._iprot)
3082 
    self._iprot.readMessageEnd()
3431 rajveer 3083 
    if result.success is not None:
2536 chandransh 3084 
      return result.success
3431 rajveer 3085 
    if result.ex is not None:
2536 chandransh 3086 
      raise result.ex
3087 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3088 
 
4602 rajveer 3089 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3090 
    """
4452 rajveer 3091 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3092 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3093 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3094 
    	3. Returns true
2591 chandransh 3095 
    If the order is in any other status, it returns false.
2536 chandransh 3096 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3097 
 
2536 chandransh 3098 
    Parameters:
3099 
     - orderId
3100 
     - pickupNumber
4602 rajveer 3101 
     - providerId
2536 chandransh 3102 
    """
4602 rajveer 3103 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3104 
    return self.recv_authorizePickup()
3105 
 
4602 rajveer 3106 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3107 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3108 
    args = authorizePickup_args()
3109 
    args.orderId = orderId
3110 
    args.pickupNumber = pickupNumber
4602 rajveer 3111 
    args.providerId = providerId
2536 chandransh 3112 
    args.write(self._oprot)
3113 
    self._oprot.writeMessageEnd()
3114 
    self._oprot.trans.flush()
3115 
 
3116 
  def recv_authorizePickup(self, ):
3117 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3118 
    if mtype == TMessageType.EXCEPTION:
3119 
      x = TApplicationException()
3120 
      x.read(self._iprot)
3121 
      self._iprot.readMessageEnd()
3122 
      raise x
3123 
    result = authorizePickup_result()
3124 
    result.read(self._iprot)
3125 
    self._iprot.readMessageEnd()
3431 rajveer 3126 
    if result.success is not None:
2536 chandransh 3127 
      return result.success
3431 rajveer 3128 
    if result.ex is not None:
2536 chandransh 3129 
      raise result.ex
3130 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3131 
 
2764 chandransh 3132 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3133 
    """
3134 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3135 
 
2764 chandransh 3136 
    Parameters:
3137 
     - providerId
3138 
     - pickupDetails
3139 
    """
3140 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3141 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3142 
 
3143 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3144 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3145 
    args = markDoasAsPickedUp_args()
3146 
    args.providerId = providerId
3147 
    args.pickupDetails = pickupDetails
3148 
    args.write(self._oprot)
3149 
    self._oprot.writeMessageEnd()
3150 
    self._oprot.trans.flush()
3151 
 
3152 
  def recv_markDoasAsPickedUp(self, ):
3153 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3154 
    if mtype == TMessageType.EXCEPTION:
3155 
      x = TApplicationException()
3156 
      x.read(self._iprot)
3157 
      self._iprot.readMessageEnd()
3158 
      raise x
3159 
    result = markDoasAsPickedUp_result()
3160 
    result.read(self._iprot)
3161 
    self._iprot.readMessageEnd()
4910 phani.kuma 3162 
    return
3163 
 
3164 
  def getDoasNotPickedUp(self, providerId):
3165 
    """
3166 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3167 
 
3168 
    Parameters:
3169 
     - providerId
3170 
    """
3171 
    self.send_getDoasNotPickedUp(providerId)
3172 
    return self.recv_getDoasNotPickedUp()
3173 
 
3174 
  def send_getDoasNotPickedUp(self, providerId):
3175 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3176 
    args = getDoasNotPickedUp_args()
3177 
    args.providerId = providerId
3178 
    args.write(self._oprot)
3179 
    self._oprot.writeMessageEnd()
3180 
    self._oprot.trans.flush()
3181 
 
3182 
  def recv_getDoasNotPickedUp(self, ):
3183 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3184 
    if mtype == TMessageType.EXCEPTION:
3185 
      x = TApplicationException()
3186 
      x.read(self._iprot)
3187 
      self._iprot.readMessageEnd()
3188 
      raise x
3189 
    result = getDoasNotPickedUp_result()
3190 
    result.read(self._iprot)
3191 
    self._iprot.readMessageEnd()
3431 rajveer 3192 
    if result.success is not None:
2764 chandransh 3193 
      return result.success
4910 phani.kuma 3194 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3195 
 
4741 phani.kuma 3196 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3197 
    """
3198 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3199 
 
3200 
    Parameters:
3201 
     - providerId
3202 
     - pickupDetails
3203 
    """
3204 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3205 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3206 
 
3207 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3208 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3209 
    args = markReturnOrdersAsPickedUp_args()
3210 
    args.providerId = providerId
3211 
    args.pickupDetails = pickupDetails
3212 
    args.write(self._oprot)
3213 
    self._oprot.writeMessageEnd()
3214 
    self._oprot.trans.flush()
3215 
 
3216 
  def recv_markReturnOrdersAsPickedUp(self, ):
3217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3218 
    if mtype == TMessageType.EXCEPTION:
3219 
      x = TApplicationException()
3220 
      x.read(self._iprot)
3221 
      self._iprot.readMessageEnd()
3222 
      raise x
3223 
    result = markReturnOrdersAsPickedUp_result()
3224 
    result.read(self._iprot)
3225 
    self._iprot.readMessageEnd()
4910 phani.kuma 3226 
    return
3227 
 
3228 
  def getReturnOrdersNotPickedUp(self, providerId):
3229 
    """
3230 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3231 
 
3232 
    Parameters:
3233 
     - providerId
3234 
    """
3235 
    self.send_getReturnOrdersNotPickedUp(providerId)
3236 
    return self.recv_getReturnOrdersNotPickedUp()
3237 
 
3238 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3239 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3240 
    args = getReturnOrdersNotPickedUp_args()
3241 
    args.providerId = providerId
3242 
    args.write(self._oprot)
3243 
    self._oprot.writeMessageEnd()
3244 
    self._oprot.trans.flush()
3245 
 
3246 
  def recv_getReturnOrdersNotPickedUp(self, ):
3247 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3248 
    if mtype == TMessageType.EXCEPTION:
3249 
      x = TApplicationException()
3250 
      x.read(self._iprot)
3251 
      self._iprot.readMessageEnd()
3252 
      raise x
3253 
    result = getReturnOrdersNotPickedUp_result()
3254 
    result.read(self._iprot)
3255 
    self._iprot.readMessageEnd()
4741 phani.kuma 3256 
    if result.success is not None:
3257 
      return result.success
4910 phani.kuma 3258 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3259 
 
4479 rajveer 3260 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3261 
    """
4452 rajveer 3262 
    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 3263 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3264 
    If the order is in any other state, it returns false.
3265 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3266 
 
2591 chandransh 3267 
    Parameters:
3268 
     - orderId
4479 rajveer 3269 
     - receiveCondition
2591 chandransh 3270 
    """
4479 rajveer 3271 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3272 
    return self.recv_receiveReturn()
2536 chandransh 3273 
 
4479 rajveer 3274 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3275 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3276 
    args = receiveReturn_args()
2591 chandransh 3277 
    args.orderId = orderId
4479 rajveer 3278 
    args.receiveCondition = receiveCondition
2591 chandransh 3279 
    args.write(self._oprot)
3280 
    self._oprot.writeMessageEnd()
3281 
    self._oprot.trans.flush()
3282 
 
2616 chandransh 3283 
  def recv_receiveReturn(self, ):
2591 chandransh 3284 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3285 
    if mtype == TMessageType.EXCEPTION:
3286 
      x = TApplicationException()
3287 
      x.read(self._iprot)
3288 
      self._iprot.readMessageEnd()
3289 
      raise x
2616 chandransh 3290 
    result = receiveReturn_result()
2591 chandransh 3291 
    result.read(self._iprot)
3292 
    self._iprot.readMessageEnd()
3431 rajveer 3293 
    if result.success is not None:
2591 chandransh 3294 
      return result.success
3431 rajveer 3295 
    if result.ex is not None:
2591 chandransh 3296 
      raise result.ex
2616 chandransh 3297 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3298 
 
3299 
  def validateDoa(self, orderId, isValid):
3300 
    """
4452 rajveer 3301 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3302 
    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 3303 
    If the order is in any other state, it returns false.
3304 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3305 
 
2591 chandransh 3306 
    Parameters:
3307 
     - orderId
3308 
     - isValid
3309 
    """
3310 
    self.send_validateDoa(orderId, isValid)
3311 
    return self.recv_validateDoa()
3312 
 
3313 
  def send_validateDoa(self, orderId, isValid):
3314 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3315 
    args = validateDoa_args()
3316 
    args.orderId = orderId
3317 
    args.isValid = isValid
3318 
    args.write(self._oprot)
3319 
    self._oprot.writeMessageEnd()
3320 
    self._oprot.trans.flush()
3321 
 
3322 
  def recv_validateDoa(self, ):
3323 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3324 
    if mtype == TMessageType.EXCEPTION:
3325 
      x = TApplicationException()
3326 
      x.read(self._iprot)
3327 
      self._iprot.readMessageEnd()
3328 
      raise x
3329 
    result = validateDoa_result()
3330 
    result.read(self._iprot)
3331 
    self._iprot.readMessageEnd()
3431 rajveer 3332 
    if result.success is not None:
2591 chandransh 3333 
      return result.success
3431 rajveer 3334 
    if result.ex is not None:
2591 chandransh 3335 
      raise result.ex
3336 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3337 
 
4495 rajveer 3338 
  def validateReturnProduct(self, orderId, isUsable):
3339 
    """
3340 
    Parameters:
3341 
     - orderId
3342 
     - isUsable
3343 
    """
3344 
    self.send_validateReturnProduct(orderId, isUsable)
3345 
    return self.recv_validateReturnProduct()
3346 
 
3347 
  def send_validateReturnProduct(self, orderId, isUsable):
3348 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3349 
    args = validateReturnProduct_args()
3350 
    args.orderId = orderId
3351 
    args.isUsable = isUsable
3352 
    args.write(self._oprot)
3353 
    self._oprot.writeMessageEnd()
3354 
    self._oprot.trans.flush()
3355 
 
3356 
  def recv_validateReturnProduct(self, ):
3357 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3358 
    if mtype == TMessageType.EXCEPTION:
3359 
      x = TApplicationException()
3360 
      x.read(self._iprot)
3361 
      self._iprot.readMessageEnd()
3362 
      raise x
3363 
    result = validateReturnProduct_result()
3364 
    result.read(self._iprot)
3365 
    self._iprot.readMessageEnd()
3366 
    if result.success is not None:
3367 
      return result.success
3368 
    if result.ex is not None:
3369 
      raise result.ex
3370 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3371 
 
2616 chandransh 3372 
  def reshipOrder(self, orderId):
3373 
    """
4484 rajveer 3374 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3375 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3376 
    	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 3377 
 
3378 
    If the order is in DOA_CERT_VALID state, it does the following:
3379 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3380 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3381 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3382 
 
2616 chandransh 3383 
    Returns the id of the newly created order.
3431 rajveer 3384 
 
2616 chandransh 3385 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3386 
 
2616 chandransh 3387 
    Parameters:
3388 
     - orderId
3389 
    """
3390 
    self.send_reshipOrder(orderId)
3391 
    return self.recv_reshipOrder()
2591 chandransh 3392 
 
2616 chandransh 3393 
  def send_reshipOrder(self, orderId):
3394 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3395 
    args = reshipOrder_args()
3396 
    args.orderId = orderId
3397 
    args.write(self._oprot)
3398 
    self._oprot.writeMessageEnd()
3399 
    self._oprot.trans.flush()
3400 
 
3401 
  def recv_reshipOrder(self, ):
3402 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3403 
    if mtype == TMessageType.EXCEPTION:
3404 
      x = TApplicationException()
3405 
      x.read(self._iprot)
3406 
      self._iprot.readMessageEnd()
3407 
      raise x
3408 
    result = reshipOrder_result()
3409 
    result.read(self._iprot)
3410 
    self._iprot.readMessageEnd()
3431 rajveer 3411 
    if result.success is not None:
2616 chandransh 3412 
      return result.success
3431 rajveer 3413 
    if result.ex is not None:
2616 chandransh 3414 
      raise result.ex
3415 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3416 
 
3226 chandransh 3417 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3418 
    """
4484 rajveer 3419 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3420 
    	1. Creates a refund request for batch processing.
3421 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3422 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3423 
 
2616 chandransh 3424 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3425 
    	1. Creates a refund request for batch processing.
3226 chandransh 3426 
    	2. Cancels the reservation of the item in the warehouse.
3427 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3428 
 
3226 chandransh 3429 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3430 
    	1. Cancels the reservation of the item in the warehouse.
3431 
    	2. Marks the current order as CANCELED.
3432 
 
3433 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3434 
 
2616 chandransh 3435 
    Returns True if it is successful, False otherwise.
3431 rajveer 3436 
 
2616 chandransh 3437 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3438 
 
2616 chandransh 3439 
    Parameters:
3440 
     - orderId
3226 chandransh 3441 
     - refundedBy
3442 
     - reason
2616 chandransh 3443 
    """
3226 chandransh 3444 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3445 
    return self.recv_refundOrder()
3446 
 
3226 chandransh 3447 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3448 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3449 
    args = refundOrder_args()
3450 
    args.orderId = orderId
3226 chandransh 3451 
    args.refundedBy = refundedBy
3452 
    args.reason = reason
2616 chandransh 3453 
    args.write(self._oprot)
3454 
    self._oprot.writeMessageEnd()
3455 
    self._oprot.trans.flush()
3456 
 
3457 
  def recv_refundOrder(self, ):
3458 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3459 
    if mtype == TMessageType.EXCEPTION:
3460 
      x = TApplicationException()
3461 
      x.read(self._iprot)
3462 
      self._iprot.readMessageEnd()
3463 
      raise x
3464 
    result = refundOrder_result()
3465 
    result.read(self._iprot)
3466 
    self._iprot.readMessageEnd()
3431 rajveer 3467 
    if result.success is not None:
2616 chandransh 3468 
      return result.success
3431 rajveer 3469 
    if result.ex is not None:
2616 chandransh 3470 
      raise result.ex
3471 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3472 
 
2690 chandransh 3473 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3474 
    """
3475 
    Get all return orders created between the from and to dates for the given warehouse.
3476 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3477 
 
2690 chandransh 3478 
    Parameters:
3479 
     - warehouseId
3480 
     - fromDate
3481 
     - toDate
3482 
    """
3483 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3484 
    return self.recv_getReturnOrders()
2616 chandransh 3485 
 
2690 chandransh 3486 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3487 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3488 
    args = getReturnOrders_args()
3489 
    args.warehouseId = warehouseId
3490 
    args.fromDate = fromDate
3491 
    args.toDate = toDate
3492 
    args.write(self._oprot)
3493 
    self._oprot.writeMessageEnd()
3494 
    self._oprot.trans.flush()
3495 
 
3496 
  def recv_getReturnOrders(self, ):
3497 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3498 
    if mtype == TMessageType.EXCEPTION:
3499 
      x = TApplicationException()
3500 
      x.read(self._iprot)
3501 
      self._iprot.readMessageEnd()
3502 
      raise x
3503 
    result = getReturnOrders_result()
3504 
    result.read(self._iprot)
3505 
    self._iprot.readMessageEnd()
3431 rajveer 3506 
    if result.success is not None:
2690 chandransh 3507 
      return result.success
3508 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3509 
 
2700 chandransh 3510 
  def getReturnOrder(self, id):
3511 
    """
3512 
    Returns the ReturnOrder corresponding to the given id.
3513 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3514 
 
2700 chandransh 3515 
    Parameters:
3516 
     - id
3517 
    """
3518 
    self.send_getReturnOrder(id)
3519 
    return self.recv_getReturnOrder()
3520 
 
3521 
  def send_getReturnOrder(self, id):
3522 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3523 
    args = getReturnOrder_args()
3524 
    args.id = id
3525 
    args.write(self._oprot)
3526 
    self._oprot.writeMessageEnd()
3527 
    self._oprot.trans.flush()
3528 
 
3529 
  def recv_getReturnOrder(self, ):
3530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3531 
    if mtype == TMessageType.EXCEPTION:
3532 
      x = TApplicationException()
3533 
      x.read(self._iprot)
3534 
      self._iprot.readMessageEnd()
3535 
      raise x
3536 
    result = getReturnOrder_result()
3537 
    result.read(self._iprot)
3538 
    self._iprot.readMessageEnd()
3431 rajveer 3539 
    if result.success is not None:
2700 chandransh 3540 
      return result.success
3431 rajveer 3541 
    if result.ex is not None:
2700 chandransh 3542 
      raise result.ex
3543 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3544 
 
2690 chandransh 3545 
  def processReturn(self, returnOrderId):
3546 
    """
3547 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3548 
 
2690 chandransh 3549 
    Parameters:
3550 
     - returnOrderId
3551 
    """
3552 
    self.send_processReturn(returnOrderId)
3553 
    self.recv_processReturn()
3554 
 
3555 
  def send_processReturn(self, returnOrderId):
3556 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3557 
    args = processReturn_args()
3558 
    args.returnOrderId = returnOrderId
3559 
    args.write(self._oprot)
3560 
    self._oprot.writeMessageEnd()
3561 
    self._oprot.trans.flush()
3562 
 
3563 
  def recv_processReturn(self, ):
3564 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3565 
    if mtype == TMessageType.EXCEPTION:
3566 
      x = TApplicationException()
3567 
      x.read(self._iprot)
3568 
      self._iprot.readMessageEnd()
3569 
      raise x
3570 
    result = processReturn_result()
3571 
    result.read(self._iprot)
3572 
    self._iprot.readMessageEnd()
3431 rajveer 3573 
    if result.ex is not None:
2690 chandransh 3574 
      raise result.ex
3575 
    return
3576 
 
3451 chandransh 3577 
  def updateWeight(self, orderId, weight):
3578 
    """
3579 
    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 3580 
 
3451 chandransh 3581 
    Parameters:
3582 
     - orderId
3583 
     - weight
3584 
    """
3585 
    self.send_updateWeight(orderId, weight)
3586 
    return self.recv_updateWeight()
3587 
 
3588 
  def send_updateWeight(self, orderId, weight):
3589 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3590 
    args = updateWeight_args()
3591 
    args.orderId = orderId
3592 
    args.weight = weight
3593 
    args.write(self._oprot)
3594 
    self._oprot.writeMessageEnd()
3595 
    self._oprot.trans.flush()
3596 
 
3597 
  def recv_updateWeight(self, ):
3598 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3599 
    if mtype == TMessageType.EXCEPTION:
3600 
      x = TApplicationException()
3601 
      x.read(self._iprot)
3602 
      self._iprot.readMessageEnd()
3603 
      raise x
3604 
    result = updateWeight_result()
3605 
    result.read(self._iprot)
3606 
    self._iprot.readMessageEnd()
3607 
    if result.success is not None:
3608 
      return result.success
3609 
    if result.ex is not None:
3610 
      raise result.ex
3611 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3612 
 
3469 chandransh 3613 
  def changeItem(self, orderId, itemId):
3614 
    """
3615 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3616 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3617 
 
3469 chandransh 3618 
    Parameters:
3619 
     - orderId
3620 
     - itemId
3621 
    """
3622 
    self.send_changeItem(orderId, itemId)
3623 
    return self.recv_changeItem()
3624 
 
3625 
  def send_changeItem(self, orderId, itemId):
3626 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3627 
    args = changeItem_args()
3628 
    args.orderId = orderId
3629 
    args.itemId = itemId
3630 
    args.write(self._oprot)
3631 
    self._oprot.writeMessageEnd()
3632 
    self._oprot.trans.flush()
3633 
 
3634 
  def recv_changeItem(self, ):
3635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3636 
    if mtype == TMessageType.EXCEPTION:
3637 
      x = TApplicationException()
3638 
      x.read(self._iprot)
3639 
      self._iprot.readMessageEnd()
3640 
      raise x
3641 
    result = changeItem_result()
3642 
    result.read(self._iprot)
3643 
    self._iprot.readMessageEnd()
3644 
    if result.success is not None:
3645 
      return result.success
3646 
    if result.ex is not None:
3647 
      raise result.ex
3648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3649 
 
3650 
  def shiftToWarehouse(self, orderId, warehouseId):
3651 
    """
3652 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3653 
 
3654 
    Parameters:
3655 
     - orderId
3656 
     - warehouseId
3657 
    """
3658 
    self.send_shiftToWarehouse(orderId, warehouseId)
3659 
    return self.recv_shiftToWarehouse()
3660 
 
3661 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3662 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3663 
    args = shiftToWarehouse_args()
3664 
    args.orderId = orderId
3665 
    args.warehouseId = warehouseId
3666 
    args.write(self._oprot)
3667 
    self._oprot.writeMessageEnd()
3668 
    self._oprot.trans.flush()
3669 
 
3670 
  def recv_shiftToWarehouse(self, ):
3671 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3672 
    if mtype == TMessageType.EXCEPTION:
3673 
      x = TApplicationException()
3674 
      x.read(self._iprot)
3675 
      self._iprot.readMessageEnd()
3676 
      raise x
3677 
    result = shiftToWarehouse_result()
3678 
    result.read(self._iprot)
3679 
    self._iprot.readMessageEnd()
3680 
    if result.success is not None:
3681 
      return result.success
3682 
    if result.ex is not None:
3683 
      raise result.ex
3684 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3685 
 
4647 rajveer 3686 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3687 
    """
3688 
    Adds the given delay reason to the given order.
3986 chandransh 3689 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3690 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3691 
 
3553 chandransh 3692 
    Parameters:
3693 
     - orderId
3694 
     - delayReason
3986 chandransh 3695 
     - furtherDelay
4647 rajveer 3696 
     - delayReasonText
3553 chandransh 3697 
    """
4647 rajveer 3698 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3699 
    return self.recv_addDelayReason()
3700 
 
4647 rajveer 3701 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3702 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3703 
    args = addDelayReason_args()
3704 
    args.orderId = orderId
3705 
    args.delayReason = delayReason
3986 chandransh 3706 
    args.furtherDelay = furtherDelay
4647 rajveer 3707 
    args.delayReasonText = delayReasonText
3553 chandransh 3708 
    args.write(self._oprot)
3709 
    self._oprot.writeMessageEnd()
3710 
    self._oprot.trans.flush()
3711 
 
3712 
  def recv_addDelayReason(self, ):
3713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3714 
    if mtype == TMessageType.EXCEPTION:
3715 
      x = TApplicationException()
3716 
      x.read(self._iprot)
3717 
      self._iprot.readMessageEnd()
3718 
      raise x
3719 
    result = addDelayReason_result()
3720 
    result.read(self._iprot)
3721 
    self._iprot.readMessageEnd()
3722 
    if result.success is not None:
3723 
      return result.success
3724 
    if result.ex is not None:
3725 
      raise result.ex
3726 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3727 
 
3956 chandransh 3728 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3729 
    """
3730 
    Marks the COD orders with given AWB nos. as having been processed.
3731 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3732 
 
3956 chandransh 3733 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3734 
    1. There is no order corresponding to an AWB number.
3735 
    2. The captured amount for a payment exceeds the total payment.
3736 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3737 
 
3738 
    Parameters:
3739 
     - collectedAmountMap
3740 
     - xferBy
3741 
     - xferTxnId
3742 
     - xferDate
3743 
    """
3744 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3745 
    return self.recv_reconcileCodCollection()
3746 
 
3747 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3748 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3749 
    args = reconcileCodCollection_args()
3750 
    args.collectedAmountMap = collectedAmountMap
3751 
    args.xferBy = xferBy
3752 
    args.xferTxnId = xferTxnId
3753 
    args.xferDate = xferDate
3754 
    args.write(self._oprot)
3755 
    self._oprot.writeMessageEnd()
3756 
    self._oprot.trans.flush()
3757 
 
3758 
  def recv_reconcileCodCollection(self, ):
3759 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3760 
    if mtype == TMessageType.EXCEPTION:
3761 
      x = TApplicationException()
3762 
      x.read(self._iprot)
3763 
      self._iprot.readMessageEnd()
3764 
      raise x
3765 
    result = reconcileCodCollection_result()
3766 
    result.read(self._iprot)
3767 
    self._iprot.readMessageEnd()
3768 
    if result.success is not None:
3769 
      return result.success
3770 
    if result.ex is not None:
3771 
      raise result.ex
3772 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3773 
 
4008 mandeep.dh 3774 
  def getTransactionsRequiringExtraProcessing(self, category):
3775 
    """
4065 mandeep.dh 3776 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3777 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3778 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3779 
 
4008 mandeep.dh 3780 
    Parameters:
3781 
     - category
3782 
    """
3783 
    self.send_getTransactionsRequiringExtraProcessing(category)
3784 
    return self.recv_getTransactionsRequiringExtraProcessing()
3785 
 
3786 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3787 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3788 
    args = getTransactionsRequiringExtraProcessing_args()
3789 
    args.category = category
3790 
    args.write(self._oprot)
3791 
    self._oprot.writeMessageEnd()
3792 
    self._oprot.trans.flush()
3793 
 
3794 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3796 
    if mtype == TMessageType.EXCEPTION:
3797 
      x = TApplicationException()
3798 
      x.read(self._iprot)
3799 
      self._iprot.readMessageEnd()
3800 
      raise x
3801 
    result = getTransactionsRequiringExtraProcessing_result()
3802 
    result.read(self._iprot)
3803 
    self._iprot.readMessageEnd()
3804 
    if result.success is not None:
3805 
      return result.success
3806 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3807 
 
3808 
  def markTransactionAsProcessed(self, transactionId, category):
3809 
    """
3810 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3811 
    It essentially deletes the transaction id record for a particular
3812 
    processing type category (if present) from DB.
3813 
    This is currently used by CRM application.
4008 mandeep.dh 3814 
 
3815 
    Parameters:
3816 
     - transactionId
3817 
     - category
3818 
    """
3819 
    self.send_markTransactionAsProcessed(transactionId, category)
3820 
    self.recv_markTransactionAsProcessed()
3821 
 
3822 
  def send_markTransactionAsProcessed(self, transactionId, category):
3823 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3824 
    args = markTransactionAsProcessed_args()
3825 
    args.transactionId = transactionId
3826 
    args.category = category
3827 
    args.write(self._oprot)
3828 
    self._oprot.writeMessageEnd()
3829 
    self._oprot.trans.flush()
3830 
 
3831 
  def recv_markTransactionAsProcessed(self, ):
3832 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3833 
    if mtype == TMessageType.EXCEPTION:
3834 
      x = TApplicationException()
3835 
      x.read(self._iprot)
3836 
      self._iprot.readMessageEnd()
3837 
      raise x
3838 
    result = markTransactionAsProcessed_result()
3839 
    result.read(self._iprot)
3840 
    self._iprot.readMessageEnd()
3841 
    return
3842 
 
4018 chandransh 3843 
  def getItemWiseRiskyOrdersCount(self, ):
3844 
    """
3845 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3846 
    is defined as one whose shipping date is about to expire.
3847 
    """
3848 
    self.send_getItemWiseRiskyOrdersCount()
3849 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3850 
 
4018 chandransh 3851 
  def send_getItemWiseRiskyOrdersCount(self, ):
3852 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3853 
    args = getItemWiseRiskyOrdersCount_args()
3854 
    args.write(self._oprot)
3855 
    self._oprot.writeMessageEnd()
3856 
    self._oprot.trans.flush()
3857 
 
3858 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3859 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3860 
    if mtype == TMessageType.EXCEPTION:
3861 
      x = TApplicationException()
3862 
      x.read(self._iprot)
3863 
      self._iprot.readMessageEnd()
3864 
      raise x
3865 
    result = getItemWiseRiskyOrdersCount_result()
3866 
    result.read(self._iprot)
3867 
    self._iprot.readMessageEnd()
3868 
    if result.success is not None:
3869 
      return result.success
3870 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3871 
 
4295 varun.gupt 3872 
  def getOrdersForItemIds(self, itemIds):
3873 
    """
3874 
    Returns a list of all orders which have items with given id
3875 
 
3876 
    Parameters:
3877 
     - itemIds
3878 
    """
3879 
    self.send_getOrdersForItemIds(itemIds)
3880 
    return self.recv_getOrdersForItemIds()
3881 
 
3882 
  def send_getOrdersForItemIds(self, itemIds):
3883 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3884 
    args = getOrdersForItemIds_args()
3885 
    args.itemIds = itemIds
3886 
    args.write(self._oprot)
3887 
    self._oprot.writeMessageEnd()
3888 
    self._oprot.trans.flush()
3889 
 
3890 
  def recv_getOrdersForItemIds(self, ):
3891 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3892 
    if mtype == TMessageType.EXCEPTION:
3893 
      x = TApplicationException()
3894 
      x.read(self._iprot)
3895 
      self._iprot.readMessageEnd()
3896 
      raise x
3897 
    result = getOrdersForItemIds_result()
3898 
    result.read(self._iprot)
3899 
    self._iprot.readMessageEnd()
3900 
    if result.success is not None:
3901 
      return result.success
3902 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3903 
 
4247 rajveer 3904 
  def markOrderCancellationRequestReceived(self, orderId):
3905 
    """
3906 
    Mark order as cancellation request received. If customer sends request of cancellation of
3907 
    a particular order, this method will be called. It will just change status of the order
3908 
    depending on its current status. It also records the previous status, so that we can move
3909 
    back to that status if cancellation request is denied.
4018 chandransh 3910 
 
4247 rajveer 3911 
    Parameters:
3912 
     - orderId
3913 
    """
3914 
    self.send_markOrderCancellationRequestReceived(orderId)
3915 
    self.recv_markOrderCancellationRequestReceived()
3916 
 
3917 
  def send_markOrderCancellationRequestReceived(self, orderId):
3918 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3919 
    args = markOrderCancellationRequestReceived_args()
3920 
    args.orderId = orderId
3921 
    args.write(self._oprot)
3922 
    self._oprot.writeMessageEnd()
3923 
    self._oprot.trans.flush()
3924 
 
3925 
  def recv_markOrderCancellationRequestReceived(self, ):
3926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3927 
    if mtype == TMessageType.EXCEPTION:
3928 
      x = TApplicationException()
3929 
      x.read(self._iprot)
3930 
      self._iprot.readMessageEnd()
3931 
      raise x
3932 
    result = markOrderCancellationRequestReceived_result()
3933 
    result.read(self._iprot)
3934 
    self._iprot.readMessageEnd()
3935 
    if result.ex is not None:
3936 
      raise result.ex
3937 
    return
3938 
 
3939 
  def markOrderCancellationRequestConfirmed(self, orderId):
3940 
    """
3941 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3942 
    cancellation request confirmed. After this OM will be able to cancel the order.
3943 
 
3944 
    Parameters:
3945 
     - orderId
3946 
    """
3947 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3948 
    self.recv_markOrderCancellationRequestConfirmed()
3949 
 
3950 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3951 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3952 
    args = markOrderCancellationRequestConfirmed_args()
3953 
    args.orderId = orderId
3954 
    args.write(self._oprot)
3955 
    self._oprot.writeMessageEnd()
3956 
    self._oprot.trans.flush()
3957 
 
3958 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3960 
    if mtype == TMessageType.EXCEPTION:
3961 
      x = TApplicationException()
3962 
      x.read(self._iprot)
3963 
      self._iprot.readMessageEnd()
3964 
      raise x
3965 
    result = markOrderCancellationRequestConfirmed_result()
3966 
    result.read(self._iprot)
3967 
    self._iprot.readMessageEnd()
3968 
    if result.ex is not None:
3969 
      raise result.ex
3970 
    return
3971 
 
3972 
  def markOrderCancellationRequestDenied(self, orderId):
3973 
    """
3974 
    If we decide to not to cancel order, we will move the order ro previous status.
3975 
 
3976 
    Parameters:
3977 
     - orderId
3978 
    """
3979 
    self.send_markOrderCancellationRequestDenied(orderId)
3980 
    self.recv_markOrderCancellationRequestDenied()
3981 
 
3982 
  def send_markOrderCancellationRequestDenied(self, orderId):
3983 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3984 
    args = markOrderCancellationRequestDenied_args()
3985 
    args.orderId = orderId
3986 
    args.write(self._oprot)
3987 
    self._oprot.writeMessageEnd()
3988 
    self._oprot.trans.flush()
3989 
 
3990 
  def recv_markOrderCancellationRequestDenied(self, ):
3991 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3992 
    if mtype == TMessageType.EXCEPTION:
3993 
      x = TApplicationException()
3994 
      x.read(self._iprot)
3995 
      self._iprot.readMessageEnd()
3996 
      raise x
3997 
    result = markOrderCancellationRequestDenied_result()
3998 
    result.read(self._iprot)
3999 
    self._iprot.readMessageEnd()
4000 
    if result.ex is not None:
4001 
      raise result.ex
4002 
    return
4003 
 
4258 rajveer 4004 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4005 
    """
4258 rajveer 4006 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4007 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4008 
 
4009 
    Parameters:
4258 rajveer 4010 
     - transactionId
4247 rajveer 4011 
    """
4258 rajveer 4012 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4013 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4014 
 
4258 rajveer 4015 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4016 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4017 
    args = markTransactionAsPaymentFlagRemoved_args()
4018 
    args.transactionId = transactionId
4247 rajveer 4019 
    args.write(self._oprot)
4020 
    self._oprot.writeMessageEnd()
4021 
    self._oprot.trans.flush()
4022 
 
4258 rajveer 4023 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4024 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4025 
    if mtype == TMessageType.EXCEPTION:
4026 
      x = TApplicationException()
4027 
      x.read(self._iprot)
4028 
      self._iprot.readMessageEnd()
4029 
      raise x
4258 rajveer 4030 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4031 
    result.read(self._iprot)
4032 
    self._iprot.readMessageEnd()
4033 
    if result.ex is not None:
4034 
      raise result.ex
4035 
    return
4036 
 
4259 anupam.sin 4037 
  def refundTransaction(self, transactionId, refundedBy, reason):
4038 
    """
4039 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4040 
    need to be cancelled
4247 rajveer 4041 
 
4259 anupam.sin 4042 
    Parameters:
4043 
     - transactionId
4044 
     - refundedBy
4045 
     - reason
4046 
    """
4047 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4048 
    self.recv_refundTransaction()
4049 
 
4050 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4051 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4052 
    args = refundTransaction_args()
4053 
    args.transactionId = transactionId
4054 
    args.refundedBy = refundedBy
4055 
    args.reason = reason
4056 
    args.write(self._oprot)
4057 
    self._oprot.writeMessageEnd()
4058 
    self._oprot.trans.flush()
4059 
 
4060 
  def recv_refundTransaction(self, ):
4061 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4062 
    if mtype == TMessageType.EXCEPTION:
4063 
      x = TApplicationException()
4064 
      x.read(self._iprot)
4065 
      self._iprot.readMessageEnd()
4066 
      raise x
4067 
    result = refundTransaction_result()
4068 
    result.read(self._iprot)
4069 
    self._iprot.readMessageEnd()
4070 
    if result.ex is not None:
4071 
      raise result.ex
4072 
    return
4073 
 
4324 mandeep.dh 4074 
  def updateShipmentAddress(self, orderId, addressId):
4075 
    """
4076 
    Updates shipment address of an order. Delivery and shipping date estimates
4077 
    etc. are also updated here.
4078 
 
4079 
    Throws TransactionServiceException in case address change is not
4080 
    possible due to certain reasons such as new pincode in address is
4081 
    not serviceable etc.
4082 
 
4083 
    Parameters:
4084 
     - orderId
4085 
     - addressId
4086 
    """
4087 
    self.send_updateShipmentAddress(orderId, addressId)
4088 
    self.recv_updateShipmentAddress()
4089 
 
4090 
  def send_updateShipmentAddress(self, orderId, addressId):
4091 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4092 
    args = updateShipmentAddress_args()
4093 
    args.orderId = orderId
4094 
    args.addressId = addressId
4095 
    args.write(self._oprot)
4096 
    self._oprot.writeMessageEnd()
4097 
    self._oprot.trans.flush()
4098 
 
4099 
  def recv_updateShipmentAddress(self, ):
4100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4101 
    if mtype == TMessageType.EXCEPTION:
4102 
      x = TApplicationException()
4103 
      x.read(self._iprot)
4104 
      self._iprot.readMessageEnd()
4105 
      raise x
4106 
    result = updateShipmentAddress_result()
4107 
    result.read(self._iprot)
4108 
    self._iprot.readMessageEnd()
4109 
    if result.ex is not None:
4110 
      raise result.ex
4111 
    return
4112 
 
4285 rajveer 4113 
  def acceptOrdersForItemId(self, itemId, inventory):
4114 
    """
4115 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4116 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4117 
 
4285 rajveer 4118 
    Parameters:
4119 
     - itemId
4120 
     - inventory
4121 
    """
4122 
    self.send_acceptOrdersForItemId(itemId, inventory)
4123 
    return self.recv_acceptOrdersForItemId()
4124 
 
4125 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4126 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4127 
    args = acceptOrdersForItemId_args()
4128 
    args.itemId = itemId
4129 
    args.inventory = inventory
4130 
    args.write(self._oprot)
4131 
    self._oprot.writeMessageEnd()
4132 
    self._oprot.trans.flush()
4133 
 
4134 
  def recv_acceptOrdersForItemId(self, ):
4135 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4136 
    if mtype == TMessageType.EXCEPTION:
4137 
      x = TApplicationException()
4138 
      x.read(self._iprot)
4139 
      self._iprot.readMessageEnd()
4140 
      raise x
4141 
    result = acceptOrdersForItemId_result()
4142 
    result.read(self._iprot)
4143 
    self._iprot.readMessageEnd()
4144 
    if result.success is not None:
4145 
      return result.success
4146 
    if result.ex is not None:
4147 
      raise result.ex
4148 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4149 
 
4369 rajveer 4150 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4151 
    """
4152 
    Parameters:
4153 
     - vendorId
4154 
     - itemId
4155 
     - quantity
4156 
     - estimate
4369 rajveer 4157 
     - isReminder
4303 rajveer 4158 
    """
4369 rajveer 4159 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4160 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4161 
 
4369 rajveer 4162 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4163 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4164 
    args = markOrdersAsPORaised_args()
4165 
    args.vendorId = vendorId
4166 
    args.itemId = itemId
4167 
    args.quantity = quantity
4168 
    args.estimate = estimate
4369 rajveer 4169 
    args.isReminder = isReminder
4303 rajveer 4170 
    args.write(self._oprot)
4171 
    self._oprot.writeMessageEnd()
4172 
    self._oprot.trans.flush()
4173 
 
4174 
  def recv_markOrdersAsPORaised(self, ):
4175 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4176 
    if mtype == TMessageType.EXCEPTION:
4177 
      x = TApplicationException()
4178 
      x.read(self._iprot)
4179 
      self._iprot.readMessageEnd()
4180 
      raise x
4181 
    result = markOrdersAsPORaised_result()
4182 
    result.read(self._iprot)
4183 
    self._iprot.readMessageEnd()
4184 
    if result.ex is not None:
4185 
      raise result.ex
4186 
    return
4187 
 
4369 rajveer 4188 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4189 
    """
4190 
    Parameters:
4191 
     - vendorId
4192 
     - itemId
4193 
     - quantity
4194 
     - estimate
4369 rajveer 4195 
     - isReminder
4303 rajveer 4196 
    """
4369 rajveer 4197 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4198 
    self.recv_markOrdersAsReversalInitiated()
4199 
 
4369 rajveer 4200 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4201 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4202 
    args = markOrdersAsReversalInitiated_args()
4203 
    args.vendorId = vendorId
4204 
    args.itemId = itemId
4205 
    args.quantity = quantity
4206 
    args.estimate = estimate
4369 rajveer 4207 
    args.isReminder = isReminder
4303 rajveer 4208 
    args.write(self._oprot)
4209 
    self._oprot.writeMessageEnd()
4210 
    self._oprot.trans.flush()
4211 
 
4212 
  def recv_markOrdersAsReversalInitiated(self, ):
4213 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4214 
    if mtype == TMessageType.EXCEPTION:
4215 
      x = TApplicationException()
4216 
      x.read(self._iprot)
4217 
      self._iprot.readMessageEnd()
4218 
      raise x
4219 
    result = markOrdersAsReversalInitiated_result()
4220 
    result.read(self._iprot)
4221 
    self._iprot.readMessageEnd()
4222 
    if result.ex is not None:
4223 
      raise result.ex
4224 
    return
4225 
 
4369 rajveer 4226 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4227 
    """
4228 
    Parameters:
4229 
     - vendorId
4230 
     - itemId
4231 
     - quantity
4232 
     - estimate
4369 rajveer 4233 
     - isReminder
4303 rajveer 4234 
    """
4369 rajveer 4235 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4236 
    self.recv_markOrdersAsNotAvailabke()
4237 
 
4369 rajveer 4238 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4239 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4240 
    args = markOrdersAsNotAvailabke_args()
4241 
    args.vendorId = vendorId
4242 
    args.itemId = itemId
4243 
    args.quantity = quantity
4244 
    args.estimate = estimate
4369 rajveer 4245 
    args.isReminder = isReminder
4303 rajveer 4246 
    args.write(self._oprot)
4247 
    self._oprot.writeMessageEnd()
4248 
    self._oprot.trans.flush()
4249 
 
4250 
  def recv_markOrdersAsNotAvailabke(self, ):
4251 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4252 
    if mtype == TMessageType.EXCEPTION:
4253 
      x = TApplicationException()
4254 
      x.read(self._iprot)
4255 
      self._iprot.readMessageEnd()
4256 
      raise x
4257 
    result = markOrdersAsNotAvailabke_result()
4258 
    result.read(self._iprot)
4259 
    self._iprot.readMessageEnd()
4260 
    if result.ex is not None:
4261 
      raise result.ex
4262 
    return
4263 
 
4369 rajveer 4264 
  def markOrdersAsTimeout(self, vendorId):
4265 
    """
4266 
    Parameters:
4267 
     - vendorId
4268 
    """
4269 
    self.send_markOrdersAsTimeout(vendorId)
4270 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4271 
 
4369 rajveer 4272 
  def send_markOrdersAsTimeout(self, vendorId):
4273 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4274 
    args = markOrdersAsTimeout_args()
4275 
    args.vendorId = vendorId
4276 
    args.write(self._oprot)
4277 
    self._oprot.writeMessageEnd()
4278 
    self._oprot.trans.flush()
4279 
 
4280 
  def recv_markOrdersAsTimeout(self, ):
4281 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4282 
    if mtype == TMessageType.EXCEPTION:
4283 
      x = TApplicationException()
4284 
      x.read(self._iprot)
4285 
      self._iprot.readMessageEnd()
4286 
      raise x
4287 
    result = markOrdersAsTimeout_result()
4288 
    result.read(self._iprot)
4289 
    self._iprot.readMessageEnd()
4290 
    if result.success is not None:
4291 
      return result.success
4292 
    if result.ex is not None:
4293 
      raise result.ex
4294 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4295 
 
4662 rajveer 4296 
  def markOrderAsLostInTransit(self, orderId):
4297 
    """
4298 
    Mark order as LOST_IN_TRANSIT
4299 
 
4300 
    Parameters:
4301 
     - orderId
4302 
    """
4303 
    self.send_markOrderAsLostInTransit(orderId)
4304 
    return self.recv_markOrderAsLostInTransit()
4305 
 
4306 
  def send_markOrderAsLostInTransit(self, orderId):
4307 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4308 
    args = markOrderAsLostInTransit_args()
4309 
    args.orderId = orderId
4310 
    args.write(self._oprot)
4311 
    self._oprot.writeMessageEnd()
4312 
    self._oprot.trans.flush()
4313 
 
4314 
  def recv_markOrderAsLostInTransit(self, ):
4315 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4316 
    if mtype == TMessageType.EXCEPTION:
4317 
      x = TApplicationException()
4318 
      x.read(self._iprot)
4319 
      self._iprot.readMessageEnd()
4320 
      raise x
4321 
    result = markOrderAsLostInTransit_result()
4322 
    result.read(self._iprot)
4323 
    self._iprot.readMessageEnd()
4324 
    if result.success is not None:
4325 
      return result.success
4326 
    if result.ex is not None:
4327 
      raise result.ex
4328 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4329 
 
4386 anupam.sin 4330 
  def getOrderForAwb(self, awb):
4331 
    """
4332 
    Returns the order corresponding to an AWB number
4369 rajveer 4333 
 
4386 anupam.sin 4334 
    Parameters:
4335 
     - awb
4336 
    """
4337 
    self.send_getOrderForAwb(awb)
4338 
    return self.recv_getOrderForAwb()
4339 
 
4340 
  def send_getOrderForAwb(self, awb):
4341 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4342 
    args = getOrderForAwb_args()
4343 
    args.awb = awb
4344 
    args.write(self._oprot)
4345 
    self._oprot.writeMessageEnd()
4346 
    self._oprot.trans.flush()
4347 
 
4348 
  def recv_getOrderForAwb(self, ):
4349 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4350 
    if mtype == TMessageType.EXCEPTION:
4351 
      x = TApplicationException()
4352 
      x.read(self._iprot)
4353 
      self._iprot.readMessageEnd()
4354 
      raise x
4355 
    result = getOrderForAwb_result()
4356 
    result.read(self._iprot)
4357 
    self._iprot.readMessageEnd()
4358 
    if result.success is not None:
4359 
      return result.success
4360 
    if result.ex is not None:
4361 
      raise result.ex
4362 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4363 
 
4910 phani.kuma 4364 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4365 
    """
4910 phani.kuma 4366 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4367 
 
4506 phani.kuma 4368 
    Parameters:
4369 
     - logistics_provider_id
4910 phani.kuma 4370 
     - order_status_list
4506 phani.kuma 4371 
    """
4910 phani.kuma 4372 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4373 
    return self.recv_getOrdersForProviderForStatus()
4374 
 
4910 phani.kuma 4375 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4376 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4377 
    args = getOrdersForProviderForStatus_args()
4378 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4379 
    args.order_status_list = order_status_list
4506 phani.kuma 4380 
    args.write(self._oprot)
4381 
    self._oprot.writeMessageEnd()
4382 
    self._oprot.trans.flush()
4383 
 
4384 
  def recv_getOrdersForProviderForStatus(self, ):
4385 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4386 
    if mtype == TMessageType.EXCEPTION:
4387 
      x = TApplicationException()
4388 
      x.read(self._iprot)
4389 
      self._iprot.readMessageEnd()
4390 
      raise x
4391 
    result = getOrdersForProviderForStatus_result()
4392 
    result.read(self._iprot)
4393 
    self._iprot.readMessageEnd()
4394 
    if result.success is not None:
4395 
      return result.success
4396 
    if result.ex is not None:
4397 
      raise result.ex
4398 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4399 
 
4600 varun.gupt 4400 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4401 
    """
4402 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4403 
 
4600 varun.gupt 4404 
    Parameters:
4405 
     - vendorId
4406 
     - billingDateFrom
4407 
     - billingDateTo
4408 
    """
4409 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4410 
    return self.recv_getBilledOrdersForVendor()
4411 
 
4412 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4413 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4414 
    args = getBilledOrdersForVendor_args()
4415 
    args.vendorId = vendorId
4416 
    args.billingDateFrom = billingDateFrom
4417 
    args.billingDateTo = billingDateTo
4418 
    args.write(self._oprot)
4419 
    self._oprot.writeMessageEnd()
4420 
    self._oprot.trans.flush()
4421 
 
4422 
  def recv_getBilledOrdersForVendor(self, ):
4423 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4424 
    if mtype == TMessageType.EXCEPTION:
4425 
      x = TApplicationException()
4426 
      x.read(self._iprot)
4427 
      self._iprot.readMessageEnd()
4428 
      raise x
4429 
    result = getBilledOrdersForVendor_result()
4430 
    result.read(self._iprot)
4431 
    self._iprot.readMessageEnd()
4432 
    if result.success is not None:
4433 
      return result.success
4434 
    if result.ex is not None:
4435 
      raise result.ex
4436 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4437 
 
4607 rajveer 4438 
  def getSlippedSippingDateOrders(self, ):
4439 
    self.send_getSlippedSippingDateOrders()
4440 
    return self.recv_getSlippedSippingDateOrders()
4441 
 
4442 
  def send_getSlippedSippingDateOrders(self, ):
4443 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4444 
    args = getSlippedSippingDateOrders_args()
4445 
    args.write(self._oprot)
4446 
    self._oprot.writeMessageEnd()
4447 
    self._oprot.trans.flush()
4448 
 
4449 
  def recv_getSlippedSippingDateOrders(self, ):
4450 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4451 
    if mtype == TMessageType.EXCEPTION:
4452 
      x = TApplicationException()
4453 
      x.read(self._iprot)
4454 
      self._iprot.readMessageEnd()
4455 
      raise x
4456 
    result = getSlippedSippingDateOrders_result()
4457 
    result.read(self._iprot)
4458 
    self._iprot.readMessageEnd()
4459 
    if result.success is not None:
4460 
      return result.success
4461 
    if result.ex is not None:
4462 
      raise result.ex
4463 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4464 
 
4709 rajveer 4465 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4466 
    """
4467 
    Parameters:
4468 
     - cancelDateFrom
4469 
     - cancelDateTo
4470 
    """
4471 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4472 
    return self.recv_getCancelledOrders()
4473 
 
4474 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4475 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4476 
    args = getCancelledOrders_args()
4477 
    args.cancelDateFrom = cancelDateFrom
4478 
    args.cancelDateTo = cancelDateTo
4479 
    args.write(self._oprot)
4480 
    self._oprot.writeMessageEnd()
4481 
    self._oprot.trans.flush()
4482 
 
4483 
  def recv_getCancelledOrders(self, ):
4484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4485 
    if mtype == TMessageType.EXCEPTION:
4486 
      x = TApplicationException()
4487 
      x.read(self._iprot)
4488 
      self._iprot.readMessageEnd()
4489 
      raise x
4490 
    result = getCancelledOrders_result()
4491 
    result.read(self._iprot)
4492 
    self._iprot.readMessageEnd()
4493 
    if result.success is not None:
4494 
      return result.success
4495 
    if result.ex is not None:
4496 
      raise result.ex
4497 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4498 
 
4600 varun.gupt 4499 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4500 
    """
4501 
    Parameters:
4502 
     - mapAWBAndAmount
4503 
    """
4504 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4505 
    self.recv_saveBluedartSettlements()
4506 
 
4507 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4508 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4509 
    args = saveBluedartSettlements_args()
4510 
    args.mapAWBAndAmount = mapAWBAndAmount
4511 
    args.write(self._oprot)
4512 
    self._oprot.writeMessageEnd()
4513 
    self._oprot.trans.flush()
4514 
 
4515 
  def recv_saveBluedartSettlements(self, ):
4516 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4517 
    if mtype == TMessageType.EXCEPTION:
4518 
      x = TApplicationException()
4519 
      x.read(self._iprot)
4520 
      self._iprot.readMessageEnd()
4521 
      raise x
4522 
    result = saveBluedartSettlements_result()
4523 
    result.read(self._iprot)
4524 
    self._iprot.readMessageEnd()
4525 
    if result.ex is not None:
4526 
      raise result.ex
4527 
    return
4528 
 
4905 varun.gupt 4529 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4530 
    """
4531 
    Parameters:
4532 
     - settlementDate
4533 
     - paymentGatewayId
4905 varun.gupt 4534 
     - referenceId
4600 varun.gupt 4535 
     - serviceTax
4536 
     - otherCharges
4537 
     - netCollection
4538 
    """
4905 varun.gupt 4539 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4540 
    self.recv_savePaymentSettlements()
4541 
 
4905 varun.gupt 4542 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4543 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4544 
    args = savePaymentSettlements_args()
4545 
    args.settlementDate = settlementDate
4546 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4547 
    args.referenceId = referenceId
4600 varun.gupt 4548 
    args.serviceTax = serviceTax
4549 
    args.otherCharges = otherCharges
4550 
    args.netCollection = netCollection
4551 
    args.write(self._oprot)
4552 
    self._oprot.writeMessageEnd()
4553 
    self._oprot.trans.flush()
4554 
 
4555 
  def recv_savePaymentSettlements(self, ):
4556 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4557 
    if mtype == TMessageType.EXCEPTION:
4558 
      x = TApplicationException()
4559 
      x.read(self._iprot)
4560 
      self._iprot.readMessageEnd()
4561 
      raise x
4562 
    result = savePaymentSettlements_result()
4563 
    result.read(self._iprot)
4564 
    self._iprot.readMessageEnd()
4565 
    if result.ex is not None:
4566 
      raise result.ex
4567 
    return
4568 
 
4569 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4570 
    """
4571 
    Parameters:
4572 
     - settlementId
4573 
     - settlementDate
4574 
     - transactionDateFrom
4575 
     - transactionDateTo
4576 
     - amount
4577 
    """
4578 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4579 
    self.recv_saveEBSSettlementSummary()
4580 
 
4581 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4582 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4583 
    args = saveEBSSettlementSummary_args()
4584 
    args.settlementId = settlementId
4585 
    args.settlementDate = settlementDate
4586 
    args.transactionDateFrom = transactionDateFrom
4587 
    args.transactionDateTo = transactionDateTo
4588 
    args.amount = amount
4589 
    args.write(self._oprot)
4590 
    self._oprot.writeMessageEnd()
4591 
    self._oprot.trans.flush()
4592 
 
4593 
  def recv_saveEBSSettlementSummary(self, ):
4594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4595 
    if mtype == TMessageType.EXCEPTION:
4596 
      x = TApplicationException()
4597 
      x.read(self._iprot)
4598 
      self._iprot.readMessageEnd()
4599 
      raise x
4600 
    result = saveEBSSettlementSummary_result()
4601 
    result.read(self._iprot)
4602 
    self._iprot.readMessageEnd()
4603 
    if result.ex is not None:
4604 
      raise result.ex
4605 
    return
4606 
 
5189 varun.gupt 4607 
  def getSettlementForReferenceId(self, referenceId, isRefund):
4600 varun.gupt 4608 
    """
4609 
    Parameters:
5189 varun.gupt 4610 
     - referenceId
4611 
     - isRefund
4600 varun.gupt 4612 
    """
5189 varun.gupt 4613 
    self.send_getSettlementForReferenceId(referenceId, isRefund)
4614 
    return self.recv_getSettlementForReferenceId()
4600 varun.gupt 4615 
 
5189 varun.gupt 4616 
  def send_getSettlementForReferenceId(self, referenceId, isRefund):
4617 
    self._oprot.writeMessageBegin('getSettlementForReferenceId', TMessageType.CALL, self._seqid)
4618 
    args = getSettlementForReferenceId_args()
4619 
    args.referenceId = referenceId
4620 
    args.isRefund = isRefund
4600 varun.gupt 4621 
    args.write(self._oprot)
4622 
    self._oprot.writeMessageEnd()
4623 
    self._oprot.trans.flush()
4624 
 
5189 varun.gupt 4625 
  def recv_getSettlementForReferenceId(self, ):
4600 varun.gupt 4626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4627 
    if mtype == TMessageType.EXCEPTION:
4628 
      x = TApplicationException()
4629 
      x.read(self._iprot)
4630 
      self._iprot.readMessageEnd()
4631 
      raise x
5189 varun.gupt 4632 
    result = getSettlementForReferenceId_result()
4600 varun.gupt 4633 
    result.read(self._iprot)
4634 
    self._iprot.readMessageEnd()
4635 
    if result.success is not None:
4636 
      return result.success
4637 
    if result.ex is not None:
4638 
      raise result.ex
5189 varun.gupt 4639 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForReferenceId failed: unknown result");
4600 varun.gupt 4640 
 
4641 
  def getEBSSettlementSummaries(self, ):
4642 
    self.send_getEBSSettlementSummaries()
4643 
    return self.recv_getEBSSettlementSummaries()
4644 
 
4645 
  def send_getEBSSettlementSummaries(self, ):
4646 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4647 
    args = getEBSSettlementSummaries_args()
4648 
    args.write(self._oprot)
4649 
    self._oprot.writeMessageEnd()
4650 
    self._oprot.trans.flush()
4651 
 
4652 
  def recv_getEBSSettlementSummaries(self, ):
4653 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4654 
    if mtype == TMessageType.EXCEPTION:
4655 
      x = TApplicationException()
4656 
      x.read(self._iprot)
4657 
      self._iprot.readMessageEnd()
4658 
      raise x
4659 
    result = getEBSSettlementSummaries_result()
4660 
    result.read(self._iprot)
4661 
    self._iprot.readMessageEnd()
4662 
    if result.success is not None:
4663 
      return result.success
4664 
    if result.ex is not None:
4665 
      raise result.ex
4666 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4667 
 
4668 
  def markEBSSettlementUploaded(self, settlementId):
4669 
    """
4670 
    Parameters:
4671 
     - settlementId
4672 
    """
4673 
    self.send_markEBSSettlementUploaded(settlementId)
4674 
    self.recv_markEBSSettlementUploaded()
4675 
 
4676 
  def send_markEBSSettlementUploaded(self, settlementId):
4677 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4678 
    args = markEBSSettlementUploaded_args()
4679 
    args.settlementId = settlementId
4680 
    args.write(self._oprot)
4681 
    self._oprot.writeMessageEnd()
4682 
    self._oprot.trans.flush()
4683 
 
4684 
  def recv_markEBSSettlementUploaded(self, ):
4685 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4686 
    if mtype == TMessageType.EXCEPTION:
4687 
      x = TApplicationException()
4688 
      x.read(self._iprot)
4689 
      self._iprot.readMessageEnd()
4690 
      raise x
4691 
    result = markEBSSettlementUploaded_result()
4692 
    result.read(self._iprot)
4693 
    self._iprot.readMessageEnd()
4694 
    if result.ex is not None:
4695 
      raise result.ex
4696 
    return
4697 
 
4698 
  def getEBSSettlementDate(self, settlementId):
4699 
    """
4700 
    Parameters:
4701 
     - settlementId
4702 
    """
4703 
    self.send_getEBSSettlementDate(settlementId)
4704 
    return self.recv_getEBSSettlementDate()
4705 
 
4706 
  def send_getEBSSettlementDate(self, settlementId):
4707 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4708 
    args = getEBSSettlementDate_args()
4709 
    args.settlementId = settlementId
4710 
    args.write(self._oprot)
4711 
    self._oprot.writeMessageEnd()
4712 
    self._oprot.trans.flush()
4713 
 
4714 
  def recv_getEBSSettlementDate(self, ):
4715 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4716 
    if mtype == TMessageType.EXCEPTION:
4717 
      x = TApplicationException()
4718 
      x.read(self._iprot)
4719 
      self._iprot.readMessageEnd()
4720 
      raise x
4721 
    result = getEBSSettlementDate_result()
4722 
    result.read(self._iprot)
4723 
    self._iprot.readMessageEnd()
4724 
    if result.success is not None:
4725 
      return result.success
4726 
    if result.ex is not None:
4727 
      raise result.ex
4728 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4729 
 
4715 varun.gupt 4730 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4731 
    """
4732 
    Parameters:
4733 
     - settlementDateFrom
4734 
     - settlementDateTo
4735 
     - isRefund
4736 
    """
4737 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4738 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4739 
 
4715 varun.gupt 4740 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4741 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4742 
    args = getSettlementsByDate_args()
4743 
    args.settlementDateFrom = settlementDateFrom
4744 
    args.settlementDateTo = settlementDateTo
4745 
    args.isRefund = isRefund
4746 
    args.write(self._oprot)
4747 
    self._oprot.writeMessageEnd()
4748 
    self._oprot.trans.flush()
4749 
 
4750 
  def recv_getSettlementsByDate(self, ):
4751 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4752 
    if mtype == TMessageType.EXCEPTION:
4753 
      x = TApplicationException()
4754 
      x.read(self._iprot)
4755 
      self._iprot.readMessageEnd()
4756 
      raise x
4757 
    result = getSettlementsByDate_result()
4758 
    result.read(self._iprot)
4759 
    self._iprot.readMessageEnd()
4760 
    if result.success is not None:
4761 
      return result.success
4762 
    if result.ex is not None:
4763 
      raise result.ex
4764 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4765 
 
4766 
  def getReshippedOrderIds(self, orderIds):
4767 
    """
4768 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4769 
 
4770 
    Parameters:
4771 
     - orderIds
4772 
    """
4773 
    self.send_getReshippedOrderIds(orderIds)
4774 
    return self.recv_getReshippedOrderIds()
4775 
 
4776 
  def send_getReshippedOrderIds(self, orderIds):
4777 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4778 
    args = getReshippedOrderIds_args()
4779 
    args.orderIds = orderIds
4780 
    args.write(self._oprot)
4781 
    self._oprot.writeMessageEnd()
4782 
    self._oprot.trans.flush()
4783 
 
4784 
  def recv_getReshippedOrderIds(self, ):
4785 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4786 
    if mtype == TMessageType.EXCEPTION:
4787 
      x = TApplicationException()
4788 
      x.read(self._iprot)
4789 
      self._iprot.readMessageEnd()
4790 
      raise x
4791 
    result = getReshippedOrderIds_result()
4792 
    result.read(self._iprot)
4793 
    self._iprot.readMessageEnd()
4794 
    if result.success is not None:
4795 
      return result.success
4796 
    if result.ex is not None:
4797 
      raise result.ex
4798 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4799 
 
4875 varun.gupt 4800 
  def getOrdersWhereVendorNotPaid(self, vendorId):
4801 
    """
4802 
    Parameters:
4803 
     - vendorId
4804 
    """
4805 
    self.send_getOrdersWhereVendorNotPaid(vendorId)
4806 
    return self.recv_getOrdersWhereVendorNotPaid()
4757 mandeep.dh 4807 
 
4875 varun.gupt 4808 
  def send_getOrdersWhereVendorNotPaid(self, vendorId):
4809 
    self._oprot.writeMessageBegin('getOrdersWhereVendorNotPaid', TMessageType.CALL, self._seqid)
4810 
    args = getOrdersWhereVendorNotPaid_args()
4811 
    args.vendorId = vendorId
4812 
    args.write(self._oprot)
4813 
    self._oprot.writeMessageEnd()
4814 
    self._oprot.trans.flush()
4815 
 
4816 
  def recv_getOrdersWhereVendorNotPaid(self, ):
4817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4818 
    if mtype == TMessageType.EXCEPTION:
4819 
      x = TApplicationException()
4820 
      x.read(self._iprot)
4821 
      self._iprot.readMessageEnd()
4822 
      raise x
4823 
    result = getOrdersWhereVendorNotPaid_result()
4824 
    result.read(self._iprot)
4825 
    self._iprot.readMessageEnd()
4826 
    if result.success is not None:
4827 
      return result.success
4828 
    if result.ex is not None:
4829 
      raise result.ex
4830 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersWhereVendorNotPaid failed: unknown result");
4831 
 
5031 varun.gupt 4832 
  def getStatusDistributionOfOrders(self, startDate, endDate):
4833 
    """
4834 
    Parameters:
4835 
     - startDate
4836 
     - endDate
4837 
    """
4838 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
4839 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 4840 
 
5031 varun.gupt 4841 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
4842 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
4843 
    args = getStatusDistributionOfOrders_args()
4844 
    args.startDate = startDate
4845 
    args.endDate = endDate
4846 
    args.write(self._oprot)
4847 
    self._oprot.writeMessageEnd()
4848 
    self._oprot.trans.flush()
4849 
 
4850 
  def recv_getStatusDistributionOfOrders(self, ):
4851 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4852 
    if mtype == TMessageType.EXCEPTION:
4853 
      x = TApplicationException()
4854 
      x.read(self._iprot)
4855 
      self._iprot.readMessageEnd()
4856 
      raise x
4857 
    result = getStatusDistributionOfOrders_result()
4858 
    result.read(self._iprot)
4859 
    self._iprot.readMessageEnd()
4860 
    if result.success is not None:
4861 
      return result.success
4862 
    if result.ex is not None:
4863 
      raise result.ex
4864 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
4865 
 
5067 varun.gupt 4866 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
4867 
    """
4868 
    Parameters:
4869 
     - status
4870 
     - startDatetime
4871 
     - endDatetime
4872 
    """
4873 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
4874 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 4875 
 
5067 varun.gupt 4876 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
4877 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
4878 
    args = getOrderIdsForStatus_args()
4879 
    args.status = status
4880 
    args.startDatetime = startDatetime
4881 
    args.endDatetime = endDatetime
4882 
    args.write(self._oprot)
4883 
    self._oprot.writeMessageEnd()
4884 
    self._oprot.trans.flush()
4885 
 
4886 
  def recv_getOrderIdsForStatus(self, ):
4887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4888 
    if mtype == TMessageType.EXCEPTION:
4889 
      x = TApplicationException()
4890 
      x.read(self._iprot)
4891 
      self._iprot.readMessageEnd()
4892 
      raise x
4893 
    result = getOrderIdsForStatus_result()
4894 
    result.read(self._iprot)
4895 
    self._iprot.readMessageEnd()
4896 
    if result.success is not None:
4897 
      return result.success
4898 
    if result.ex is not None:
4899 
      raise result.ex
4900 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
4901 
 
5099 varun.gupt 4902 
  def updateOrderAsPaidToVendor(self, orderId):
4903 
    """
4904 
    Parameters:
4905 
     - orderId
4906 
    """
4907 
    self.send_updateOrderAsPaidToVendor(orderId)
4908 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 4909 
 
5099 varun.gupt 4910 
  def send_updateOrderAsPaidToVendor(self, orderId):
4911 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
4912 
    args = updateOrderAsPaidToVendor_args()
4913 
    args.orderId = orderId
4914 
    args.write(self._oprot)
4915 
    self._oprot.writeMessageEnd()
4916 
    self._oprot.trans.flush()
4917 
 
4918 
  def recv_updateOrderAsPaidToVendor(self, ):
4919 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4920 
    if mtype == TMessageType.EXCEPTION:
4921 
      x = TApplicationException()
4922 
      x.read(self._iprot)
4923 
      self._iprot.readMessageEnd()
4924 
      raise x
4925 
    result = updateOrderAsPaidToVendor_result()
4926 
    result.read(self._iprot)
4927 
    self._iprot.readMessageEnd()
4928 
    if result.ex is not None:
4929 
      raise result.ex
4930 
    return
4931 
 
5208 varun.gupt 4932 
  def getRefundedOrdersMarkedPaid(self, ):
4933 
    self.send_getRefundedOrdersMarkedPaid()
4934 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 4935 
 
5208 varun.gupt 4936 
  def send_getRefundedOrdersMarkedPaid(self, ):
4937 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
4938 
    args = getRefundedOrdersMarkedPaid_args()
4939 
    args.write(self._oprot)
4940 
    self._oprot.writeMessageEnd()
4941 
    self._oprot.trans.flush()
4942 
 
4943 
  def recv_getRefundedOrdersMarkedPaid(self, ):
4944 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4945 
    if mtype == TMessageType.EXCEPTION:
4946 
      x = TApplicationException()
4947 
      x.read(self._iprot)
4948 
      self._iprot.readMessageEnd()
4949 
      raise x
4950 
    result = getRefundedOrdersMarkedPaid_result()
4951 
    result.read(self._iprot)
4952 
    self._iprot.readMessageEnd()
4953 
    if result.success is not None:
4954 
      return result.success
4955 
    if result.ex is not None:
4956 
      raise result.ex
4957 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
4958 
 
4959 
 
3376 rajveer 4960 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4961 
  def __init__(self, handler):
3376 rajveer 4962 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4963 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4964 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4965 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4966 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4967 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4968 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4969 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4970 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4971 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4972 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4973 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4974 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4975 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4976 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4977 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4978 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4979 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4980 
    self._processMap["createOrder"] = Processor.process_createOrder
4981 
    self._processMap["getOrder"] = Processor.process_getOrder
4982 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 4983 
    self._processMap["getOrderList"] = Processor.process_getOrderList
1528 ankur.sing 4984 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 4985 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 4986 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 4987 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 4988 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
4989 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
4990 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
4991 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 4992 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 4993 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 4994 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
4995 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
4996 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 4997 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 4998 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 4999 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 5000 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 5001 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 5002 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
5003 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 5004 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 5005 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
5006 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
5007 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
5008 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
5009 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 5010 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 5011 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 5012 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 5013 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 5014 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
5015 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 5016 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
5017 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 5018 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
5019 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 5020 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 5021 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 5022 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 5023 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 5024 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 5025 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 5026 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 5027 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
5028 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 5029 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 5030 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 5031 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 5032 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 5033 
    self._processMap["changeItem"] = Processor.process_changeItem
5034 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 5035 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 5036 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 5037 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
5038 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 5039 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 5040 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 5041 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
5042 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
5043 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 5044 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 5045 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 5046 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 5047 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 5048 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
5049 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
5050 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 5051 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 5052 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 5053 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 5054 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 5055 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 5056 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 5057 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 5058 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
5059 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
5060 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5189 varun.gupt 5061 
    self._processMap["getSettlementForReferenceId"] = Processor.process_getSettlementForReferenceId
4600 varun.gupt 5062 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
5063 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
5064 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 5065 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
5066 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
4875 varun.gupt 5067 
    self._processMap["getOrdersWhereVendorNotPaid"] = Processor.process_getOrdersWhereVendorNotPaid
5031 varun.gupt 5068 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 5069 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5099 varun.gupt 5070 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5208 varun.gupt 5071 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
94 ashish 5072 
 
5073 
  def process(self, iprot, oprot):
5074 
    (name, type, seqid) = iprot.readMessageBegin()
5075 
    if name not in self._processMap:
5076 
      iprot.skip(TType.STRUCT)
5077 
      iprot.readMessageEnd()
5078 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5079 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5080 
      x.write(oprot)
5081 
      oprot.writeMessageEnd()
5082 
      oprot.trans.flush()
5083 
      return
5084 
    else:
5085 
      self._processMap[name](self, seqid, iprot, oprot)
5086 
    return True
5087 
 
5088 
  def process_createTransaction(self, seqid, iprot, oprot):
5089 
    args = createTransaction_args()
5090 
    args.read(iprot)
5091 
    iprot.readMessageEnd()
5092 
    result = createTransaction_result()
5093 
    try:
132 ashish 5094 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 5095 
    except TransactionServiceException, ex:
5096 
      result.ex = ex
5097 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
5098 
    result.write(oprot)
5099 
    oprot.writeMessageEnd()
5100 
    oprot.trans.flush()
5101 
 
5102 
  def process_getTransaction(self, seqid, iprot, oprot):
5103 
    args = getTransaction_args()
5104 
    args.read(iprot)
5105 
    iprot.readMessageEnd()
5106 
    result = getTransaction_result()
5107 
    try:
5108 
      result.success = self._handler.getTransaction(args.id)
5109 
    except TransactionServiceException, ex:
5110 
      result.ex = ex
5111 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
5112 
    result.write(oprot)
5113 
    oprot.writeMessageEnd()
5114 
    oprot.trans.flush()
5115 
 
5116 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
5117 
    args = getTransactionsForCustomer_args()
5118 
    args.read(iprot)
5119 
    iprot.readMessageEnd()
5120 
    result = getTransactionsForCustomer_result()
5121 
    try:
5122 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
5123 
    except TransactionServiceException, ex:
5124 
      result.ex = ex
5125 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
5126 
    result.write(oprot)
5127 
    oprot.writeMessageEnd()
5128 
    oprot.trans.flush()
5129 
 
132 ashish 5130 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
5131 
    args = getTransactionsForShoppingCartId_args()
5132 
    args.read(iprot)
5133 
    iprot.readMessageEnd()
5134 
    result = getTransactionsForShoppingCartId_result()
5135 
    try:
5136 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
5137 
    except TransactionServiceException, ex:
5138 
      result.ex = ex
5139 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
5140 
    result.write(oprot)
5141 
    oprot.writeMessageEnd()
5142 
    oprot.trans.flush()
5143 
 
94 ashish 5144 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
5145 
    args = getTransactionStatus_args()
5146 
    args.read(iprot)
5147 
    iprot.readMessageEnd()
5148 
    result = getTransactionStatus_result()
5149 
    try:
5150 
      result.success = self._handler.getTransactionStatus(args.transactionId)
5151 
    except TransactionServiceException, ex:
5152 
      result.ex = ex
5153 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
5154 
    result.write(oprot)
5155 
    oprot.writeMessageEnd()
5156 
    oprot.trans.flush()
5157 
 
5158 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
5159 
    args = changeTransactionStatus_args()
5160 
    args.read(iprot)
5161 
    iprot.readMessageEnd()
5162 
    result = changeTransactionStatus_result()
5163 
    try:
5164 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
5165 
    except TransactionServiceException, ex:
5166 
      result.ex = ex
5167 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
5168 
    result.write(oprot)
5169 
    oprot.writeMessageEnd()
5170 
    oprot.trans.flush()
5171 
 
1398 varun.gupt 5172 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
5173 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 5174 
    args.read(iprot)
5175 
    iprot.readMessageEnd()
1398 varun.gupt 5176 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 5177 
    try:
1398 varun.gupt 5178 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 5179 
    except TransactionServiceException, ex:
5180 
      result.ex = ex
1398 varun.gupt 5181 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 5182 
    result.write(oprot)
5183 
    oprot.writeMessageEnd()
5184 
    oprot.trans.flush()
5185 
 
483 rajveer 5186 
  def process_getAllOrders(self, seqid, iprot, oprot):
5187 
    args = getAllOrders_args()
94 ashish 5188 
    args.read(iprot)
5189 
    iprot.readMessageEnd()
483 rajveer 5190 
    result = getAllOrders_result()
94 ashish 5191 
    try:
4801 anupam.sin 5192 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 5193 
    except TransactionServiceException, ex:
5194 
      result.ex = ex
483 rajveer 5195 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 5196 
    result.write(oprot)
5197 
    oprot.writeMessageEnd()
5198 
    oprot.trans.flush()
5199 
 
4133 chandransh 5200 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
5201 
    args = getOrdersInBatch_args()
5202 
    args.read(iprot)
5203 
    iprot.readMessageEnd()
5204 
    result = getOrdersInBatch_result()
5205 
    try:
5206 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
5207 
    except TransactionServiceException, ex:
5208 
      result.ex = ex
5209 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
5210 
    result.write(oprot)
5211 
    oprot.writeMessageEnd()
5212 
    oprot.trans.flush()
5213 
 
5214 
  def process_getOrderCount(self, seqid, iprot, oprot):
5215 
    args = getOrderCount_args()
5216 
    args.read(iprot)
5217 
    iprot.readMessageEnd()
5218 
    result = getOrderCount_result()
5219 
    try:
5220 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
5221 
    except TransactionServiceException, ex:
5222 
      result.ex = ex
5223 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
5224 
    result.write(oprot)
5225 
    oprot.writeMessageEnd()
5226 
    oprot.trans.flush()
5227 
 
999 varun.gupt 5228 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
5229 
    args = getOrdersByBillingDate_args()
5230 
    args.read(iprot)
5231 
    iprot.readMessageEnd()
5232 
    result = getOrdersByBillingDate_result()
5233 
    try:
5234 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
5235 
    except TransactionServiceException, ex:
5236 
      result.ex = ex
5237 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
5238 
    result.write(oprot)
5239 
    oprot.writeMessageEnd()
5240 
    oprot.trans.flush()
5241 
 
3427 chandransh 5242 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
5243 
    args = getOrdersByShippingDate_args()
5244 
    args.read(iprot)
5245 
    iprot.readMessageEnd()
5246 
    result = getOrdersByShippingDate_result()
5247 
    try:
3451 chandransh 5248 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 5249 
    except TransactionServiceException, ex:
5250 
      result.ex = ex
5251 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
5252 
    result.write(oprot)
5253 
    oprot.writeMessageEnd()
5254 
    oprot.trans.flush()
5255 
 
1382 varun.gupt 5256 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
5257 
    args = getReturnableOrdersForCustomer_args()
5258 
    args.read(iprot)
5259 
    iprot.readMessageEnd()
5260 
    result = getReturnableOrdersForCustomer_result()
5261 
    try:
5262 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
5263 
    except TransactionServiceException, ex:
5264 
      result.ex = ex
5265 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
5266 
    result.write(oprot)
5267 
    oprot.writeMessageEnd()
5268 
    oprot.trans.flush()
5269 
 
5270 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
5271 
    args = getCancellableOrdersForCustomer_args()
5272 
    args.read(iprot)
5273 
    iprot.readMessageEnd()
5274 
    result = getCancellableOrdersForCustomer_result()
5275 
    try:
5276 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
5277 
    except TransactionServiceException, ex:
5278 
      result.ex = ex
5279 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
5280 
    result.write(oprot)
5281 
    oprot.writeMessageEnd()
5282 
    oprot.trans.flush()
5283 
 
483 rajveer 5284 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
5285 
    args = changeOrderStatus_args()
94 ashish 5286 
    args.read(iprot)
5287 
    iprot.readMessageEnd()
483 rajveer 5288 
    result = changeOrderStatus_result()
94 ashish 5289 
    try:
483 rajveer 5290 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 5291 
    except TransactionServiceException, ex:
5292 
      result.ex = ex
483 rajveer 5293 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 5294 
    result.write(oprot)
5295 
    oprot.writeMessageEnd()
5296 
    oprot.trans.flush()
5297 
 
483 rajveer 5298 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
5299 
    args = getOrdersForTransaction_args()
94 ashish 5300 
    args.read(iprot)
5301 
    iprot.readMessageEnd()
483 rajveer 5302 
    result = getOrdersForTransaction_result()
94 ashish 5303 
    try:
1528 ankur.sing 5304 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 5305 
    except TransactionServiceException, ex:
5306 
      result.ex = ex
483 rajveer 5307 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 5308 
    result.write(oprot)
5309 
    oprot.writeMessageEnd()
5310 
    oprot.trans.flush()
5311 
 
483 rajveer 5312 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
5313 
    args = getOrdersForCustomer_args()
94 ashish 5314 
    args.read(iprot)
5315 
    iprot.readMessageEnd()
483 rajveer 5316 
    result = getOrdersForCustomer_result()
94 ashish 5317 
    try:
3014 chandransh 5318 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 5319 
    except TransactionServiceException, ex:
5320 
      result.ex = ex
483 rajveer 5321 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 5322 
    result.write(oprot)
5323 
    oprot.writeMessageEnd()
5324 
    oprot.trans.flush()
5325 
 
483 rajveer 5326 
  def process_createOrder(self, seqid, iprot, oprot):
5327 
    args = createOrder_args()
94 ashish 5328 
    args.read(iprot)
5329 
    iprot.readMessageEnd()
483 rajveer 5330 
    result = createOrder_result()
94 ashish 5331 
    try:
483 rajveer 5332 
      result.success = self._handler.createOrder(args.order)
94 ashish 5333 
    except TransactionServiceException, ex:
5334 
      result.ex = ex
483 rajveer 5335 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 5336 
    result.write(oprot)
5337 
    oprot.writeMessageEnd()
5338 
    oprot.trans.flush()
5339 
 
483 rajveer 5340 
  def process_getOrder(self, seqid, iprot, oprot):
5341 
    args = getOrder_args()
94 ashish 5342 
    args.read(iprot)
5343 
    iprot.readMessageEnd()
483 rajveer 5344 
    result = getOrder_result()
94 ashish 5345 
    try:
483 rajveer 5346 
      result.success = self._handler.getOrder(args.id)
94 ashish 5347 
    except TransactionServiceException, ex:
5348 
      result.ex = ex
483 rajveer 5349 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 5350 
    result.write(oprot)
5351 
    oprot.writeMessageEnd()
5352 
    oprot.trans.flush()
5353 
 
483 rajveer 5354 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
5355 
    args = getLineItemsForOrder_args()
94 ashish 5356 
    args.read(iprot)
5357 
    iprot.readMessageEnd()
483 rajveer 5358 
    result = getLineItemsForOrder_result()
94 ashish 5359 
    try:
483 rajveer 5360 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 5361 
    except TransactionServiceException, ex:
5362 
      result.ex = ex
483 rajveer 5363 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 5364 
    result.write(oprot)
5365 
    oprot.writeMessageEnd()
5366 
    oprot.trans.flush()
5367 
 
4999 phani.kuma 5368 
  def process_getOrderList(self, seqid, iprot, oprot):
5369 
    args = getOrderList_args()
5370 
    args.read(iprot)
5371 
    iprot.readMessageEnd()
5372 
    result = getOrderList_result()
5373 
    result.success = self._handler.getOrderList(args.order_ids)
5374 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
5375 
    result.write(oprot)
5376 
    oprot.writeMessageEnd()
5377 
    oprot.trans.flush()
5378 
 
1528 ankur.sing 5379 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
5380 
    args = getOrderForCustomer_args()
5381 
    args.read(iprot)
5382 
    iprot.readMessageEnd()
5383 
    result = getOrderForCustomer_result()
5384 
    try:
5385 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
5386 
    except TransactionServiceException, ex:
5387 
      result.ex = ex
5388 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
5389 
    result.write(oprot)
5390 
    oprot.writeMessageEnd()
5391 
    oprot.trans.flush()
5392 
 
3064 chandransh 5393 
  def process_getAlerts(self, seqid, iprot, oprot):
5394 
    args = getAlerts_args()
5395 
    args.read(iprot)
5396 
    iprot.readMessageEnd()
5397 
    result = getAlerts_result()
4444 rajveer 5398 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 5399 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
5400 
    result.write(oprot)
5401 
    oprot.writeMessageEnd()
5402 
    oprot.trans.flush()
5403 
 
4394 rajveer 5404 
  def process_addAlert(self, seqid, iprot, oprot):
5405 
    args = addAlert_args()
3064 chandransh 5406 
    args.read(iprot)
5407 
    iprot.readMessageEnd()
4394 rajveer 5408 
    result = addAlert_result()
4444 rajveer 5409 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 5410 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 5411 
    result.write(oprot)
5412 
    oprot.writeMessageEnd()
5413 
    oprot.trans.flush()
5414 
 
4444 rajveer 5415 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
5416 
    args = markAlertsAsSeen_args()
5417 
    args.read(iprot)
5418 
    iprot.readMessageEnd()
5419 
    result = markAlertsAsSeen_result()
5420 
    self._handler.markAlertsAsSeen(args.warehouseId)
5421 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
5422 
    result.write(oprot)
5423 
    oprot.writeMessageEnd()
5424 
    oprot.trans.flush()
5425 
 
3064 chandransh 5426 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
5427 
    args = getValidOrderCount_args()
5428 
    args.read(iprot)
5429 
    iprot.readMessageEnd()
5430 
    result = getValidOrderCount_result()
5431 
    result.success = self._handler.getValidOrderCount()
5432 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
5433 
    result.write(oprot)
5434 
    oprot.writeMessageEnd()
5435 
    oprot.trans.flush()
5436 
 
5437 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
5438 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
5439 
    args.read(iprot)
5440 
    iprot.readMessageEnd()
5441 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
5442 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
5443 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
5444 
    result.write(oprot)
5445 
    oprot.writeMessageEnd()
5446 
    oprot.trans.flush()
5447 
 
5448 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
5449 
    args = getValidOrdersAmountRange_args()
5450 
    args.read(iprot)
5451 
    iprot.readMessageEnd()
5452 
    result = getValidOrdersAmountRange_result()
5453 
    result.success = self._handler.getValidOrdersAmountRange()
5454 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
5455 
    result.write(oprot)
5456 
    oprot.writeMessageEnd()
5457 
    oprot.trans.flush()
5458 
 
5459 
  def process_getValidOrders(self, seqid, iprot, oprot):
5460 
    args = getValidOrders_args()
5461 
    args.read(iprot)
5462 
    iprot.readMessageEnd()
5463 
    result = getValidOrders_result()
5464 
    result.success = self._handler.getValidOrders(args.limit)
5465 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
5466 
    result.write(oprot)
5467 
    oprot.writeMessageEnd()
5468 
    oprot.trans.flush()
5469 
 
1220 chandransh 5470 
  def process_batchOrders(self, seqid, iprot, oprot):
5471 
    args = batchOrders_args()
5472 
    args.read(iprot)
5473 
    iprot.readMessageEnd()
5474 
    result = batchOrders_result()
5475 
    try:
5476 
      result.success = self._handler.batchOrders(args.warehouseId)
5477 
    except TransactionServiceException, ex:
5478 
      result.ex = ex
5479 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
5480 
    result.write(oprot)
5481 
    oprot.writeMessageEnd()
5482 
    oprot.trans.flush()
5483 
 
1208 chandransh 5484 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
5485 
    args = markOrderAsOutOfStock_args()
5486 
    args.read(iprot)
5487 
    iprot.readMessageEnd()
5488 
    result = markOrderAsOutOfStock_result()
5489 
    try:
5490 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
5491 
    except TransactionServiceException, ex:
5492 
      result.ex = ex
5493 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
5494 
    result.write(oprot)
5495 
    oprot.writeMessageEnd()
5496 
    oprot.trans.flush()
5497 
 
3064 chandransh 5498 
  def process_verifyOrder(self, seqid, iprot, oprot):
5499 
    args = verifyOrder_args()
759 chandransh 5500 
    args.read(iprot)
5501 
    iprot.readMessageEnd()
3064 chandransh 5502 
    result = verifyOrder_result()
759 chandransh 5503 
    try:
3064 chandransh 5504 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 5505 
    except TransactionServiceException, ex:
5506 
      result.ex = ex
3064 chandransh 5507 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 5508 
    result.write(oprot)
5509 
    oprot.writeMessageEnd()
5510 
    oprot.trans.flush()
5511 
 
3064 chandransh 5512 
  def process_acceptOrder(self, seqid, iprot, oprot):
5513 
    args = acceptOrder_args()
1113 chandransh 5514 
    args.read(iprot)
5515 
    iprot.readMessageEnd()
3064 chandransh 5516 
    result = acceptOrder_result()
1113 chandransh 5517 
    try:
3064 chandransh 5518 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 5519 
    except TransactionServiceException, ex:
5520 
      result.ex = ex
3064 chandransh 5521 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 5522 
    result.write(oprot)
5523 
    oprot.writeMessageEnd()
5524 
    oprot.trans.flush()
5525 
 
3064 chandransh 5526 
  def process_addBillingDetails(self, seqid, iprot, oprot):
5527 
    args = addBillingDetails_args()
1135 chandransh 5528 
    args.read(iprot)
5529 
    iprot.readMessageEnd()
3064 chandransh 5530 
    result = addBillingDetails_result()
1135 chandransh 5531 
    try:
5110 mandeep.dh 5532 
      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 5533 
    except TransactionServiceException, ex:
5534 
      result.ex = ex
3064 chandransh 5535 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 5536 
    result.write(oprot)
5537 
    oprot.writeMessageEnd()
5538 
    oprot.trans.flush()
5539 
 
4579 rajveer 5540 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
5541 
    args = addInvoiceNumber_args()
5542 
    args.read(iprot)
5543 
    iprot.readMessageEnd()
5544 
    result = addInvoiceNumber_result()
5545 
    try:
4763 rajveer 5546 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 5547 
    except TransactionServiceException, ex:
5548 
      result.ex = ex
5549 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
5550 
    result.write(oprot)
5551 
    oprot.writeMessageEnd()
5552 
    oprot.trans.flush()
5553 
 
4410 rajveer 5554 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5555 
    args = markOrdersAsShippedFromWarehouse_args()
5556 
    args.read(iprot)
5557 
    iprot.readMessageEnd()
5558 
    result = markOrdersAsShippedFromWarehouse_result()
5559 
    try:
4789 rajveer 5560 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 5561 
    except TransactionServiceException, ex:
5562 
      result.ex = ex
5563 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5564 
    result.write(oprot)
5565 
    oprot.writeMessageEnd()
5566 
    oprot.trans.flush()
5567 
 
3064 chandransh 5568 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5569 
    args = markOrdersAsPickedUp_args()
304 ashish 5570 
    args.read(iprot)
5571 
    iprot.readMessageEnd()
3064 chandransh 5572 
    result = markOrdersAsPickedUp_result()
5573 
    try:
4910 phani.kuma 5574 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 5575 
    except TransactionServiceException, ex:
5576 
      result.ex = ex
5577 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5578 
    result.write(oprot)
5579 
    oprot.writeMessageEnd()
5580 
    oprot.trans.flush()
94 ashish 5581 
 
4910 phani.kuma 5582 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
5583 
    args = getOrdersNotPickedUp_args()
5584 
    args.read(iprot)
5585 
    iprot.readMessageEnd()
5586 
    result = getOrdersNotPickedUp_result()
5587 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
5588 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
5589 
    result.write(oprot)
5590 
    oprot.writeMessageEnd()
5591 
    oprot.trans.flush()
5592 
 
3064 chandransh 5593 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5594 
    args = markOrdersAsDelivered_args()
304 ashish 5595 
    args.read(iprot)
5596 
    iprot.readMessageEnd()
3064 chandransh 5597 
    result = markOrdersAsDelivered_result()
5598 
    try:
5599 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5600 
    except TransactionServiceException, ex:
5601 
      result.ex = ex
5602 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5603 
    result.write(oprot)
5604 
    oprot.writeMessageEnd()
5605 
    oprot.trans.flush()
5606 
 
4910 phani.kuma 5607 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
5608 
    args = markAsRTOrders_args()
1596 ankur.sing 5609 
    args.read(iprot)
5610 
    iprot.readMessageEnd()
4910 phani.kuma 5611 
    result = markAsRTOrders_result()
3064 chandransh 5612 
    try:
4910 phani.kuma 5613 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 5614 
    except TransactionServiceException, ex:
5615 
      result.ex = ex
4910 phani.kuma 5616 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 5617 
    result.write(oprot)
5618 
    oprot.writeMessageEnd()
5619 
    oprot.trans.flush()
304 ashish 5620 
 
4910 phani.kuma 5621 
  def process_getRTOrders(self, seqid, iprot, oprot):
5622 
    args = getRTOrders_args()
5623 
    args.read(iprot)
5624 
    iprot.readMessageEnd()
5625 
    result = getRTOrders_result()
5626 
    result.success = self._handler.getRTOrders(args.providerId)
5627 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
5628 
    result.write(oprot)
5629 
    oprot.writeMessageEnd()
5630 
    oprot.trans.flush()
5631 
 
3064 chandransh 5632 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5633 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5634 
    args.read(iprot)
5635 
    iprot.readMessageEnd()
3064 chandransh 5636 
    result = updateNonDeliveryReason_result()
5637 
    try:
4910 phani.kuma 5638 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5639 
    except TransactionServiceException, ex:
5640 
      result.ex = ex
5641 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5642 
    result.write(oprot)
5643 
    oprot.writeMessageEnd()
5644 
    oprot.trans.flush()
1596 ankur.sing 5645 
 
4910 phani.kuma 5646 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
5647 
    args = getNonDeliveredOrdersbyCourier_args()
5648 
    args.read(iprot)
5649 
    iprot.readMessageEnd()
5650 
    result = getNonDeliveredOrdersbyCourier_result()
5651 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
5652 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
5653 
    result.write(oprot)
5654 
    oprot.writeMessageEnd()
5655 
    oprot.trans.flush()
5656 
 
5657 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
5658 
    args = markOrdersAsLocalConnected_args()
5659 
    args.read(iprot)
5660 
    iprot.readMessageEnd()
5661 
    result = markOrdersAsLocalConnected_result()
5662 
    try:
5663 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
5664 
    except TransactionServiceException, ex:
5665 
      result.ex = ex
5666 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
5667 
    result.write(oprot)
5668 
    oprot.writeMessageEnd()
5669 
    oprot.trans.flush()
5670 
 
5671 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
5672 
    args = getOrdersNotLocalConnected_args()
5673 
    args.read(iprot)
5674 
    iprot.readMessageEnd()
5675 
    result = getOrdersNotLocalConnected_result()
5676 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
5677 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
5678 
    result.write(oprot)
5679 
    oprot.writeMessageEnd()
5680 
    oprot.trans.flush()
5681 
 
5682 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
5683 
    args = markOrdersAsDestinationCityReached_args()
5684 
    args.read(iprot)
5685 
    iprot.readMessageEnd()
5686 
    result = markOrdersAsDestinationCityReached_result()
5687 
    try:
5688 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
5689 
    except TransactionServiceException, ex:
5690 
      result.ex = ex
5691 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
5692 
    result.write(oprot)
5693 
    oprot.writeMessageEnd()
5694 
    oprot.trans.flush()
5695 
 
5696 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
5697 
    args = markOrdersAsFirstDeliveryAttempted_args()
5698 
    args.read(iprot)
5699 
    iprot.readMessageEnd()
5700 
    result = markOrdersAsFirstDeliveryAttempted_result()
5701 
    try:
5702 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
5703 
    except TransactionServiceException, ex:
5704 
      result.ex = ex
5705 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
5706 
    result.write(oprot)
5707 
    oprot.writeMessageEnd()
5708 
    oprot.trans.flush()
5709 
 
3064 chandransh 5710 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5711 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5712 
    args.read(iprot)
5713 
    iprot.readMessageEnd()
3064 chandransh 5714 
    result = getUndeliveredOrders_result()
5715 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5716 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5717 
    result.write(oprot)
5718 
    oprot.writeMessageEnd()
5719 
    oprot.trans.flush()
5720 
 
4783 phani.kuma 5721 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
5722 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
5723 
    args.read(iprot)
5724 
    iprot.readMessageEnd()
5725 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
5726 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
5727 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
5728 
    result.write(oprot)
5729 
    oprot.writeMessageEnd()
5730 
    oprot.trans.flush()
5731 
 
2536 chandransh 5732 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5733 
    args = toggleDOAFlag_args()
5734 
    args.read(iprot)
5735 
    iprot.readMessageEnd()
5736 
    result = toggleDOAFlag_result()
5737 
    try:
5738 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5739 
    except TransactionServiceException, ex:
5740 
      result.ex = ex
5741 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5742 
    result.write(oprot)
5743 
    oprot.writeMessageEnd()
5744 
    oprot.trans.flush()
1886 ankur.sing 5745 
 
4712 rajveer 5746 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5747 
    args = markOrderAsDelivered_args()
5748 
    args.read(iprot)
5749 
    iprot.readMessageEnd()
5750 
    result = markOrderAsDelivered_result()
5751 
    try:
5752 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5753 
    except TransactionServiceException, ex:
5754 
      result.ex = ex
5755 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5756 
    result.write(oprot)
5757 
    oprot.writeMessageEnd()
5758 
    oprot.trans.flush()
5759 
 
4454 rajveer 5760 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5761 
    args = markOrderDoaRequestReceived_args()
5762 
    args.read(iprot)
5763 
    iprot.readMessageEnd()
5764 
    result = markOrderDoaRequestReceived_result()
5765 
    try:
5766 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5767 
    except TransactionServiceException, ex:
5768 
      result.ex = ex
5769 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5770 
    result.write(oprot)
5771 
    oprot.writeMessageEnd()
5772 
    oprot.trans.flush()
5773 
 
5774 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
5775 
    args = markOrderDoaRequestAuthorized_args()
5776 
    args.read(iprot)
5777 
    iprot.readMessageEnd()
5778 
    result = markOrderDoaRequestAuthorized_result()
5779 
    try:
5780 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
5781 
    except TransactionServiceException, ex:
5782 
      result.ex = ex
5783 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
5784 
    result.write(oprot)
5785 
    oprot.writeMessageEnd()
5786 
    oprot.trans.flush()
5787 
 
4488 rajveer 5788 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5789 
    args = markOrderReturnRequestReceived_args()
5790 
    args.read(iprot)
5791 
    iprot.readMessageEnd()
5792 
    result = markOrderReturnRequestReceived_result()
5793 
    try:
5794 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5795 
    except TransactionServiceException, ex:
5796 
      result.ex = ex
5797 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5798 
    result.write(oprot)
5799 
    oprot.writeMessageEnd()
5800 
    oprot.trans.flush()
5801 
 
5802 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5803 
    args = markOrderReturnRequestAuthorized_args()
5804 
    args.read(iprot)
5805 
    iprot.readMessageEnd()
5806 
    result = markOrderReturnRequestAuthorized_result()
5807 
    try:
5808 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5809 
    except TransactionServiceException, ex:
5810 
      result.ex = ex
5811 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5812 
    result.write(oprot)
5813 
    oprot.writeMessageEnd()
5814 
    oprot.trans.flush()
5815 
 
2536 chandransh 5816 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5817 
    args = requestPickupNumber_args()
5818 
    args.read(iprot)
5819 
    iprot.readMessageEnd()
5820 
    result = requestPickupNumber_result()
5821 
    try:
4579 rajveer 5822 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 5823 
    except TransactionServiceException, ex:
5824 
      result.ex = ex
5825 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
5826 
    result.write(oprot)
5827 
    oprot.writeMessageEnd()
5828 
    oprot.trans.flush()
5829 
 
5830 
  def process_authorizePickup(self, seqid, iprot, oprot):
5831 
    args = authorizePickup_args()
5832 
    args.read(iprot)
5833 
    iprot.readMessageEnd()
5834 
    result = authorizePickup_result()
5835 
    try:
4602 rajveer 5836 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 5837 
    except TransactionServiceException, ex:
5838 
      result.ex = ex
5839 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
5840 
    result.write(oprot)
5841 
    oprot.writeMessageEnd()
5842 
    oprot.trans.flush()
5843 
 
2764 chandransh 5844 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
5845 
    args = markDoasAsPickedUp_args()
5846 
    args.read(iprot)
5847 
    iprot.readMessageEnd()
5848 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 5849 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 5850 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
5851 
    result.write(oprot)
5852 
    oprot.writeMessageEnd()
5853 
    oprot.trans.flush()
5854 
 
4910 phani.kuma 5855 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
5856 
    args = getDoasNotPickedUp_args()
5857 
    args.read(iprot)
5858 
    iprot.readMessageEnd()
5859 
    result = getDoasNotPickedUp_result()
5860 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
5861 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
5862 
    result.write(oprot)
5863 
    oprot.writeMessageEnd()
5864 
    oprot.trans.flush()
5865 
 
4741 phani.kuma 5866 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
5867 
    args = markReturnOrdersAsPickedUp_args()
5868 
    args.read(iprot)
5869 
    iprot.readMessageEnd()
5870 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 5871 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 5872 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
5873 
    result.write(oprot)
5874 
    oprot.writeMessageEnd()
5875 
    oprot.trans.flush()
5876 
 
4910 phani.kuma 5877 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
5878 
    args = getReturnOrdersNotPickedUp_args()
5879 
    args.read(iprot)
5880 
    iprot.readMessageEnd()
5881 
    result = getReturnOrdersNotPickedUp_result()
5882 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
5883 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
5884 
    result.write(oprot)
5885 
    oprot.writeMessageEnd()
5886 
    oprot.trans.flush()
5887 
 
2616 chandransh 5888 
  def process_receiveReturn(self, seqid, iprot, oprot):
5889 
    args = receiveReturn_args()
2591 chandransh 5890 
    args.read(iprot)
5891 
    iprot.readMessageEnd()
2616 chandransh 5892 
    result = receiveReturn_result()
2591 chandransh 5893 
    try:
4479 rajveer 5894 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 5895 
    except TransactionServiceException, ex:
5896 
      result.ex = ex
2616 chandransh 5897 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 5898 
    result.write(oprot)
5899 
    oprot.writeMessageEnd()
5900 
    oprot.trans.flush()
2536 chandransh 5901 
 
2591 chandransh 5902 
  def process_validateDoa(self, seqid, iprot, oprot):
5903 
    args = validateDoa_args()
5904 
    args.read(iprot)
5905 
    iprot.readMessageEnd()
5906 
    result = validateDoa_result()
5907 
    try:
5908 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
5909 
    except TransactionServiceException, ex:
5910 
      result.ex = ex
5911 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
5912 
    result.write(oprot)
5913 
    oprot.writeMessageEnd()
5914 
    oprot.trans.flush()
5915 
 
4495 rajveer 5916 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
5917 
    args = validateReturnProduct_args()
5918 
    args.read(iprot)
5919 
    iprot.readMessageEnd()
5920 
    result = validateReturnProduct_result()
5921 
    try:
5922 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
5923 
    except TransactionServiceException, ex:
5924 
      result.ex = ex
5925 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
5926 
    result.write(oprot)
5927 
    oprot.writeMessageEnd()
5928 
    oprot.trans.flush()
5929 
 
2616 chandransh 5930 
  def process_reshipOrder(self, seqid, iprot, oprot):
5931 
    args = reshipOrder_args()
5932 
    args.read(iprot)
5933 
    iprot.readMessageEnd()
5934 
    result = reshipOrder_result()
5935 
    try:
5936 
      result.success = self._handler.reshipOrder(args.orderId)
5937 
    except TransactionServiceException, ex:
5938 
      result.ex = ex
5939 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
5940 
    result.write(oprot)
5941 
    oprot.writeMessageEnd()
5942 
    oprot.trans.flush()
2591 chandransh 5943 
 
2616 chandransh 5944 
  def process_refundOrder(self, seqid, iprot, oprot):
5945 
    args = refundOrder_args()
5946 
    args.read(iprot)
5947 
    iprot.readMessageEnd()
5948 
    result = refundOrder_result()
5949 
    try:
3226 chandransh 5950 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 5951 
    except TransactionServiceException, ex:
5952 
      result.ex = ex
5953 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
5954 
    result.write(oprot)
5955 
    oprot.writeMessageEnd()
5956 
    oprot.trans.flush()
5957 
 
2690 chandransh 5958 
  def process_getReturnOrders(self, seqid, iprot, oprot):
5959 
    args = getReturnOrders_args()
5960 
    args.read(iprot)
5961 
    iprot.readMessageEnd()
5962 
    result = getReturnOrders_result()
5963 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
5964 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
5965 
    result.write(oprot)
5966 
    oprot.writeMessageEnd()
5967 
    oprot.trans.flush()
2616 chandransh 5968 
 
2700 chandransh 5969 
  def process_getReturnOrder(self, seqid, iprot, oprot):
5970 
    args = getReturnOrder_args()
5971 
    args.read(iprot)
5972 
    iprot.readMessageEnd()
5973 
    result = getReturnOrder_result()
5974 
    try:
5975 
      result.success = self._handler.getReturnOrder(args.id)
5976 
    except TransactionServiceException, ex:
5977 
      result.ex = ex
5978 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
5979 
    result.write(oprot)
5980 
    oprot.writeMessageEnd()
5981 
    oprot.trans.flush()
5982 
 
2690 chandransh 5983 
  def process_processReturn(self, seqid, iprot, oprot):
5984 
    args = processReturn_args()
5985 
    args.read(iprot)
5986 
    iprot.readMessageEnd()
5987 
    result = processReturn_result()
5988 
    try:
5989 
      self._handler.processReturn(args.returnOrderId)
5990 
    except TransactionServiceException, ex:
5991 
      result.ex = ex
5992 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
5993 
    result.write(oprot)
5994 
    oprot.writeMessageEnd()
5995 
    oprot.trans.flush()
5996 
 
3451 chandransh 5997 
  def process_updateWeight(self, seqid, iprot, oprot):
5998 
    args = updateWeight_args()
5999 
    args.read(iprot)
6000 
    iprot.readMessageEnd()
6001 
    result = updateWeight_result()
6002 
    try:
6003 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
6004 
    except TransactionServiceException, ex:
6005 
      result.ex = ex
6006 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
6007 
    result.write(oprot)
6008 
    oprot.writeMessageEnd()
6009 
    oprot.trans.flush()
2819 chandransh 6010 
 
3469 chandransh 6011 
  def process_changeItem(self, seqid, iprot, oprot):
6012 
    args = changeItem_args()
6013 
    args.read(iprot)
6014 
    iprot.readMessageEnd()
6015 
    result = changeItem_result()
6016 
    try:
6017 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
6018 
    except TransactionServiceException, ex:
6019 
      result.ex = ex
6020 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
6021 
    result.write(oprot)
6022 
    oprot.writeMessageEnd()
6023 
    oprot.trans.flush()
3451 chandransh 6024 
 
3469 chandransh 6025 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
6026 
    args = shiftToWarehouse_args()
6027 
    args.read(iprot)
6028 
    iprot.readMessageEnd()
6029 
    result = shiftToWarehouse_result()
6030 
    try:
6031 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
6032 
    except TransactionServiceException, ex:
6033 
      result.ex = ex
6034 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
6035 
    result.write(oprot)
6036 
    oprot.writeMessageEnd()
6037 
    oprot.trans.flush()
6038 
 
3553 chandransh 6039 
  def process_addDelayReason(self, seqid, iprot, oprot):
6040 
    args = addDelayReason_args()
6041 
    args.read(iprot)
6042 
    iprot.readMessageEnd()
6043 
    result = addDelayReason_result()
6044 
    try:
4647 rajveer 6045 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 6046 
    except TransactionServiceException, ex:
6047 
      result.ex = ex
6048 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
6049 
    result.write(oprot)
6050 
    oprot.writeMessageEnd()
6051 
    oprot.trans.flush()
3469 chandransh 6052 
 
3956 chandransh 6053 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
6054 
    args = reconcileCodCollection_args()
6055 
    args.read(iprot)
6056 
    iprot.readMessageEnd()
6057 
    result = reconcileCodCollection_result()
6058 
    try:
6059 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
6060 
    except TransactionServiceException, ex:
6061 
      result.ex = ex
6062 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
6063 
    result.write(oprot)
6064 
    oprot.writeMessageEnd()
6065 
    oprot.trans.flush()
3553 chandransh 6066 
 
4008 mandeep.dh 6067 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
6068 
    args = getTransactionsRequiringExtraProcessing_args()
6069 
    args.read(iprot)
6070 
    iprot.readMessageEnd()
6071 
    result = getTransactionsRequiringExtraProcessing_result()
6072 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
6073 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
6074 
    result.write(oprot)
6075 
    oprot.writeMessageEnd()
6076 
    oprot.trans.flush()
3956 chandransh 6077 
 
4008 mandeep.dh 6078 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
6079 
    args = markTransactionAsProcessed_args()
6080 
    args.read(iprot)
6081 
    iprot.readMessageEnd()
6082 
    result = markTransactionAsProcessed_result()
6083 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
6084 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
6085 
    result.write(oprot)
6086 
    oprot.writeMessageEnd()
6087 
    oprot.trans.flush()
6088 
 
4018 chandransh 6089 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
6090 
    args = getItemWiseRiskyOrdersCount_args()
6091 
    args.read(iprot)
6092 
    iprot.readMessageEnd()
6093 
    result = getItemWiseRiskyOrdersCount_result()
6094 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
6095 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
6096 
    result.write(oprot)
6097 
    oprot.writeMessageEnd()
6098 
    oprot.trans.flush()
4008 mandeep.dh 6099 
 
4295 varun.gupt 6100 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
6101 
    args = getOrdersForItemIds_args()
6102 
    args.read(iprot)
6103 
    iprot.readMessageEnd()
6104 
    result = getOrdersForItemIds_result()
6105 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
6106 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
6107 
    result.write(oprot)
6108 
    oprot.writeMessageEnd()
6109 
    oprot.trans.flush()
6110 
 
4247 rajveer 6111 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
6112 
    args = markOrderCancellationRequestReceived_args()
6113 
    args.read(iprot)
6114 
    iprot.readMessageEnd()
6115 
    result = markOrderCancellationRequestReceived_result()
6116 
    try:
6117 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
6118 
    except TransactionServiceException, ex:
6119 
      result.ex = ex
6120 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
6121 
    result.write(oprot)
6122 
    oprot.writeMessageEnd()
6123 
    oprot.trans.flush()
4018 chandransh 6124 
 
4247 rajveer 6125 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
6126 
    args = markOrderCancellationRequestConfirmed_args()
6127 
    args.read(iprot)
6128 
    iprot.readMessageEnd()
6129 
    result = markOrderCancellationRequestConfirmed_result()
6130 
    try:
6131 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
6132 
    except TransactionServiceException, ex:
6133 
      result.ex = ex
6134 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
6135 
    result.write(oprot)
6136 
    oprot.writeMessageEnd()
6137 
    oprot.trans.flush()
6138 
 
6139 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
6140 
    args = markOrderCancellationRequestDenied_args()
6141 
    args.read(iprot)
6142 
    iprot.readMessageEnd()
6143 
    result = markOrderCancellationRequestDenied_result()
6144 
    try:
6145 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
6146 
    except TransactionServiceException, ex:
6147 
      result.ex = ex
6148 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
6149 
    result.write(oprot)
6150 
    oprot.writeMessageEnd()
6151 
    oprot.trans.flush()
6152 
 
4258 rajveer 6153 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
6154 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 6155 
    args.read(iprot)
6156 
    iprot.readMessageEnd()
4258 rajveer 6157 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 6158 
    try:
4258 rajveer 6159 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 6160 
    except TransactionServiceException, ex:
6161 
      result.ex = ex
4258 rajveer 6162 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 6163 
    result.write(oprot)
6164 
    oprot.writeMessageEnd()
6165 
    oprot.trans.flush()
6166 
 
4259 anupam.sin 6167 
  def process_refundTransaction(self, seqid, iprot, oprot):
6168 
    args = refundTransaction_args()
6169 
    args.read(iprot)
6170 
    iprot.readMessageEnd()
6171 
    result = refundTransaction_result()
6172 
    try:
6173 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
6174 
    except TransactionServiceException, ex:
6175 
      result.ex = ex
6176 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
6177 
    result.write(oprot)
6178 
    oprot.writeMessageEnd()
6179 
    oprot.trans.flush()
4247 rajveer 6180 
 
4324 mandeep.dh 6181 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
6182 
    args = updateShipmentAddress_args()
6183 
    args.read(iprot)
6184 
    iprot.readMessageEnd()
6185 
    result = updateShipmentAddress_result()
6186 
    try:
6187 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
6188 
    except TransactionServiceException, ex:
6189 
      result.ex = ex
6190 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
6191 
    result.write(oprot)
6192 
    oprot.writeMessageEnd()
6193 
    oprot.trans.flush()
6194 
 
4285 rajveer 6195 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
6196 
    args = acceptOrdersForItemId_args()
6197 
    args.read(iprot)
6198 
    iprot.readMessageEnd()
6199 
    result = acceptOrdersForItemId_result()
6200 
    try:
6201 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
6202 
    except TransactionServiceException, ex:
6203 
      result.ex = ex
6204 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
6205 
    result.write(oprot)
6206 
    oprot.writeMessageEnd()
6207 
    oprot.trans.flush()
4259 anupam.sin 6208 
 
4303 rajveer 6209 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
6210 
    args = markOrdersAsPORaised_args()
6211 
    args.read(iprot)
6212 
    iprot.readMessageEnd()
6213 
    result = markOrdersAsPORaised_result()
6214 
    try:
4369 rajveer 6215 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6216 
    except TransactionServiceException, ex:
6217 
      result.ex = ex
6218 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
6219 
    result.write(oprot)
6220 
    oprot.writeMessageEnd()
6221 
    oprot.trans.flush()
4285 rajveer 6222 
 
4303 rajveer 6223 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
6224 
    args = markOrdersAsReversalInitiated_args()
6225 
    args.read(iprot)
6226 
    iprot.readMessageEnd()
6227 
    result = markOrdersAsReversalInitiated_result()
6228 
    try:
4369 rajveer 6229 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6230 
    except TransactionServiceException, ex:
6231 
      result.ex = ex
6232 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
6233 
    result.write(oprot)
6234 
    oprot.writeMessageEnd()
6235 
    oprot.trans.flush()
6236 
 
6237 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
6238 
    args = markOrdersAsNotAvailabke_args()
6239 
    args.read(iprot)
6240 
    iprot.readMessageEnd()
6241 
    result = markOrdersAsNotAvailabke_result()
6242 
    try:
4369 rajveer 6243 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6244 
    except TransactionServiceException, ex:
6245 
      result.ex = ex
6246 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
6247 
    result.write(oprot)
6248 
    oprot.writeMessageEnd()
6249 
    oprot.trans.flush()
6250 
 
4369 rajveer 6251 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
6252 
    args = markOrdersAsTimeout_args()
6253 
    args.read(iprot)
6254 
    iprot.readMessageEnd()
6255 
    result = markOrdersAsTimeout_result()
6256 
    try:
6257 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
6258 
    except TransactionServiceException, ex:
6259 
      result.ex = ex
6260 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
6261 
    result.write(oprot)
6262 
    oprot.writeMessageEnd()
6263 
    oprot.trans.flush()
4303 rajveer 6264 
 
4662 rajveer 6265 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
6266 
    args = markOrderAsLostInTransit_args()
6267 
    args.read(iprot)
6268 
    iprot.readMessageEnd()
6269 
    result = markOrderAsLostInTransit_result()
6270 
    try:
6271 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
6272 
    except TransactionServiceException, ex:
6273 
      result.ex = ex
6274 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
6275 
    result.write(oprot)
6276 
    oprot.writeMessageEnd()
6277 
    oprot.trans.flush()
6278 
 
4386 anupam.sin 6279 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
6280 
    args = getOrderForAwb_args()
6281 
    args.read(iprot)
6282 
    iprot.readMessageEnd()
6283 
    result = getOrderForAwb_result()
6284 
    try:
6285 
      result.success = self._handler.getOrderForAwb(args.awb)
6286 
    except TransactionServiceException, ex:
6287 
      result.ex = ex
6288 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
6289 
    result.write(oprot)
6290 
    oprot.writeMessageEnd()
6291 
    oprot.trans.flush()
4369 rajveer 6292 
 
4506 phani.kuma 6293 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
6294 
    args = getOrdersForProviderForStatus_args()
6295 
    args.read(iprot)
6296 
    iprot.readMessageEnd()
6297 
    result = getOrdersForProviderForStatus_result()
6298 
    try:
4910 phani.kuma 6299 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 6300 
    except TransactionServiceException, ex:
6301 
      result.ex = ex
6302 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
6303 
    result.write(oprot)
6304 
    oprot.writeMessageEnd()
6305 
    oprot.trans.flush()
4386 anupam.sin 6306 
 
4600 varun.gupt 6307 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
6308 
    args = getBilledOrdersForVendor_args()
6309 
    args.read(iprot)
6310 
    iprot.readMessageEnd()
6311 
    result = getBilledOrdersForVendor_result()
6312 
    try:
6313 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
6314 
    except TransactionServiceException, ex:
6315 
      result.ex = ex
6316 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
6317 
    result.write(oprot)
6318 
    oprot.writeMessageEnd()
6319 
    oprot.trans.flush()
4506 phani.kuma 6320 
 
4607 rajveer 6321 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
6322 
    args = getSlippedSippingDateOrders_args()
6323 
    args.read(iprot)
6324 
    iprot.readMessageEnd()
6325 
    result = getSlippedSippingDateOrders_result()
6326 
    try:
6327 
      result.success = self._handler.getSlippedSippingDateOrders()
6328 
    except TransactionServiceException, ex:
6329 
      result.ex = ex
6330 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
6331 
    result.write(oprot)
6332 
    oprot.writeMessageEnd()
6333 
    oprot.trans.flush()
6334 
 
4709 rajveer 6335 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
6336 
    args = getCancelledOrders_args()
6337 
    args.read(iprot)
6338 
    iprot.readMessageEnd()
6339 
    result = getCancelledOrders_result()
6340 
    try:
6341 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
6342 
    except TransactionServiceException, ex:
6343 
      result.ex = ex
6344 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
6345 
    result.write(oprot)
6346 
    oprot.writeMessageEnd()
6347 
    oprot.trans.flush()
6348 
 
4600 varun.gupt 6349 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
6350 
    args = saveBluedartSettlements_args()
6351 
    args.read(iprot)
6352 
    iprot.readMessageEnd()
6353 
    result = saveBluedartSettlements_result()
6354 
    try:
6355 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
6356 
    except TransactionServiceException, ex:
6357 
      result.ex = ex
6358 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
6359 
    result.write(oprot)
6360 
    oprot.writeMessageEnd()
6361 
    oprot.trans.flush()
6362 
 
6363 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
6364 
    args = savePaymentSettlements_args()
6365 
    args.read(iprot)
6366 
    iprot.readMessageEnd()
6367 
    result = savePaymentSettlements_result()
6368 
    try:
4905 varun.gupt 6369 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 6370 
    except TransactionServiceException, ex:
6371 
      result.ex = ex
6372 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
6373 
    result.write(oprot)
6374 
    oprot.writeMessageEnd()
6375 
    oprot.trans.flush()
6376 
 
6377 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
6378 
    args = saveEBSSettlementSummary_args()
6379 
    args.read(iprot)
6380 
    iprot.readMessageEnd()
6381 
    result = saveEBSSettlementSummary_result()
6382 
    try:
6383 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
6384 
    except TransactionServiceException, ex:
6385 
      result.ex = ex
6386 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
6387 
    result.write(oprot)
6388 
    oprot.writeMessageEnd()
6389 
    oprot.trans.flush()
6390 
 
5189 varun.gupt 6391 
  def process_getSettlementForReferenceId(self, seqid, iprot, oprot):
6392 
    args = getSettlementForReferenceId_args()
4600 varun.gupt 6393 
    args.read(iprot)
6394 
    iprot.readMessageEnd()
5189 varun.gupt 6395 
    result = getSettlementForReferenceId_result()
4600 varun.gupt 6396 
    try:
5189 varun.gupt 6397 
      result.success = self._handler.getSettlementForReferenceId(args.referenceId, args.isRefund)
4600 varun.gupt 6398 
    except TransactionServiceException, ex:
6399 
      result.ex = ex
5189 varun.gupt 6400 
    oprot.writeMessageBegin("getSettlementForReferenceId", TMessageType.REPLY, seqid)
4600 varun.gupt 6401 
    result.write(oprot)
6402 
    oprot.writeMessageEnd()
6403 
    oprot.trans.flush()
6404 
 
6405 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
6406 
    args = getEBSSettlementSummaries_args()
6407 
    args.read(iprot)
6408 
    iprot.readMessageEnd()
6409 
    result = getEBSSettlementSummaries_result()
6410 
    try:
6411 
      result.success = self._handler.getEBSSettlementSummaries()
6412 
    except TransactionServiceException, ex:
6413 
      result.ex = ex
6414 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
6415 
    result.write(oprot)
6416 
    oprot.writeMessageEnd()
6417 
    oprot.trans.flush()
6418 
 
6419 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
6420 
    args = markEBSSettlementUploaded_args()
6421 
    args.read(iprot)
6422 
    iprot.readMessageEnd()
6423 
    result = markEBSSettlementUploaded_result()
6424 
    try:
6425 
      self._handler.markEBSSettlementUploaded(args.settlementId)
6426 
    except TransactionServiceException, ex:
6427 
      result.ex = ex
6428 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
6429 
    result.write(oprot)
6430 
    oprot.writeMessageEnd()
6431 
    oprot.trans.flush()
6432 
 
6433 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
6434 
    args = getEBSSettlementDate_args()
6435 
    args.read(iprot)
6436 
    iprot.readMessageEnd()
6437 
    result = getEBSSettlementDate_result()
6438 
    try:
6439 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
6440 
    except TransactionServiceException, ex:
6441 
      result.ex = ex
6442 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
6443 
    result.write(oprot)
6444 
    oprot.writeMessageEnd()
6445 
    oprot.trans.flush()
6446 
 
4715 varun.gupt 6447 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
6448 
    args = getSettlementsByDate_args()
6449 
    args.read(iprot)
6450 
    iprot.readMessageEnd()
6451 
    result = getSettlementsByDate_result()
6452 
    try:
6453 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
6454 
    except TransactionServiceException, ex:
6455 
      result.ex = ex
6456 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
6457 
    result.write(oprot)
6458 
    oprot.writeMessageEnd()
6459 
    oprot.trans.flush()
4600 varun.gupt 6460 
 
4715 varun.gupt 6461 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
6462 
    args = getReshippedOrderIds_args()
6463 
    args.read(iprot)
6464 
    iprot.readMessageEnd()
6465 
    result = getReshippedOrderIds_result()
6466 
    try:
6467 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
6468 
    except TransactionServiceException, ex:
6469 
      result.ex = ex
6470 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
6471 
    result.write(oprot)
6472 
    oprot.writeMessageEnd()
6473 
    oprot.trans.flush()
6474 
 
4875 varun.gupt 6475 
  def process_getOrdersWhereVendorNotPaid(self, seqid, iprot, oprot):
6476 
    args = getOrdersWhereVendorNotPaid_args()
6477 
    args.read(iprot)
6478 
    iprot.readMessageEnd()
6479 
    result = getOrdersWhereVendorNotPaid_result()
6480 
    try:
6481 
      result.success = self._handler.getOrdersWhereVendorNotPaid(args.vendorId)
6482 
    except TransactionServiceException, ex:
6483 
      result.ex = ex
6484 
    oprot.writeMessageBegin("getOrdersWhereVendorNotPaid", TMessageType.REPLY, seqid)
6485 
    result.write(oprot)
6486 
    oprot.writeMessageEnd()
6487 
    oprot.trans.flush()
4757 mandeep.dh 6488 
 
5031 varun.gupt 6489 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
6490 
    args = getStatusDistributionOfOrders_args()
6491 
    args.read(iprot)
6492 
    iprot.readMessageEnd()
6493 
    result = getStatusDistributionOfOrders_result()
6494 
    try:
6495 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
6496 
    except TransactionServiceException, ex:
6497 
      result.ex = ex
6498 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
6499 
    result.write(oprot)
6500 
    oprot.writeMessageEnd()
6501 
    oprot.trans.flush()
4875 varun.gupt 6502 
 
5067 varun.gupt 6503 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
6504 
    args = getOrderIdsForStatus_args()
6505 
    args.read(iprot)
6506 
    iprot.readMessageEnd()
6507 
    result = getOrderIdsForStatus_result()
6508 
    try:
6509 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
6510 
    except TransactionServiceException, ex:
6511 
      result.ex = ex
6512 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
6513 
    result.write(oprot)
6514 
    oprot.writeMessageEnd()
6515 
    oprot.trans.flush()
5031 varun.gupt 6516 
 
5099 varun.gupt 6517 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
6518 
    args = updateOrderAsPaidToVendor_args()
6519 
    args.read(iprot)
6520 
    iprot.readMessageEnd()
6521 
    result = updateOrderAsPaidToVendor_result()
6522 
    try:
6523 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
6524 
    except TransactionServiceException, ex:
6525 
      result.ex = ex
6526 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
6527 
    result.write(oprot)
6528 
    oprot.writeMessageEnd()
6529 
    oprot.trans.flush()
5067 varun.gupt 6530 
 
5208 varun.gupt 6531 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
6532 
    args = getRefundedOrdersMarkedPaid_args()
6533 
    args.read(iprot)
6534 
    iprot.readMessageEnd()
6535 
    result = getRefundedOrdersMarkedPaid_result()
6536 
    try:
6537 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
6538 
    except TransactionServiceException, ex:
6539 
      result.ex = ex
6540 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
6541 
    result.write(oprot)
6542 
    oprot.writeMessageEnd()
6543 
    oprot.trans.flush()
5099 varun.gupt 6544 
 
5208 varun.gupt 6545 
 
94 ashish 6546 
# HELPER FUNCTIONS AND STRUCTURES
6547 
 
6548 
class createTransaction_args:
6549 
  """
6550 
  Attributes:
6551 
   - transaction
6552 
  """
6553 
 
6554 
  thrift_spec = (
6555 
    None, # 0
6556 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
6557 
  )
6558 
 
6559 
  def __init__(self, transaction=None,):
6560 
    self.transaction = transaction
6561 
 
6562 
  def read(self, iprot):
6563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6565 
      return
6566 
    iprot.readStructBegin()
6567 
    while True:
6568 
      (fname, ftype, fid) = iprot.readFieldBegin()
6569 
      if ftype == TType.STOP:
6570 
        break
6571 
      if fid == 1:
6572 
        if ftype == TType.STRUCT:
6573 
          self.transaction = Transaction()
6574 
          self.transaction.read(iprot)
6575 
        else:
6576 
          iprot.skip(ftype)
6577 
      else:
6578 
        iprot.skip(ftype)
6579 
      iprot.readFieldEnd()
6580 
    iprot.readStructEnd()
6581 
 
6582 
  def write(self, oprot):
6583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6585 
      return
6586 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 6587 
    if self.transaction is not None:
94 ashish 6588 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
6589 
      self.transaction.write(oprot)
6590 
      oprot.writeFieldEnd()
6591 
    oprot.writeFieldStop()
6592 
    oprot.writeStructEnd()
6593 
 
3431 rajveer 6594 
  def validate(self):
6595 
    return
6596 
 
6597 
 
94 ashish 6598 
  def __repr__(self):
6599 
    L = ['%s=%r' % (key, value)
6600 
      for key, value in self.__dict__.iteritems()]
6601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6602 
 
6603 
  def __eq__(self, other):
6604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6605 
 
6606 
  def __ne__(self, other):
6607 
    return not (self == other)
6608 
 
6609 
class createTransaction_result:
6610 
  """
6611 
  Attributes:
132 ashish 6612 
   - success
94 ashish 6613 
   - ex
6614 
  """
6615 
 
6616 
  thrift_spec = (
132 ashish 6617 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 6618 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6619 
  )
6620 
 
132 ashish 6621 
  def __init__(self, success=None, ex=None,):
6622 
    self.success = success
94 ashish 6623 
    self.ex = ex
6624 
 
6625 
  def read(self, iprot):
6626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6628 
      return
6629 
    iprot.readStructBegin()
6630 
    while True:
6631 
      (fname, ftype, fid) = iprot.readFieldBegin()
6632 
      if ftype == TType.STOP:
6633 
        break
132 ashish 6634 
      if fid == 0:
6635 
        if ftype == TType.I64:
6636 
          self.success = iprot.readI64();
6637 
        else:
6638 
          iprot.skip(ftype)
6639 
      elif fid == 1:
94 ashish 6640 
        if ftype == TType.STRUCT:
6641 
          self.ex = TransactionServiceException()
6642 
          self.ex.read(iprot)
6643 
        else:
6644 
          iprot.skip(ftype)
6645 
      else:
6646 
        iprot.skip(ftype)
6647 
      iprot.readFieldEnd()
6648 
    iprot.readStructEnd()
6649 
 
6650 
  def write(self, oprot):
6651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6653 
      return
6654 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 6655 
    if self.success is not None:
132 ashish 6656 
      oprot.writeFieldBegin('success', TType.I64, 0)
6657 
      oprot.writeI64(self.success)
6658 
      oprot.writeFieldEnd()
3431 rajveer 6659 
    if self.ex is not None:
94 ashish 6660 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6661 
      self.ex.write(oprot)
6662 
      oprot.writeFieldEnd()
6663 
    oprot.writeFieldStop()
6664 
    oprot.writeStructEnd()
6665 
 
3431 rajveer 6666 
  def validate(self):
6667 
    return
6668 
 
6669 
 
94 ashish 6670 
  def __repr__(self):
6671 
    L = ['%s=%r' % (key, value)
6672 
      for key, value in self.__dict__.iteritems()]
6673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6674 
 
6675 
  def __eq__(self, other):
6676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6677 
 
6678 
  def __ne__(self, other):
6679 
    return not (self == other)
6680 
 
6681 
class getTransaction_args:
6682 
  """
6683 
  Attributes:
6684 
   - id
6685 
  """
6686 
 
6687 
  thrift_spec = (
6688 
    None, # 0
6689 
    (1, TType.I64, 'id', None, None, ), # 1
6690 
  )
6691 
 
6692 
  def __init__(self, id=None,):
6693 
    self.id = id
6694 
 
6695 
  def read(self, iprot):
6696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6698 
      return
6699 
    iprot.readStructBegin()
6700 
    while True:
6701 
      (fname, ftype, fid) = iprot.readFieldBegin()
6702 
      if ftype == TType.STOP:
6703 
        break
6704 
      if fid == 1:
6705 
        if ftype == TType.I64:
6706 
          self.id = iprot.readI64();
6707 
        else:
6708 
          iprot.skip(ftype)
6709 
      else:
6710 
        iprot.skip(ftype)
6711 
      iprot.readFieldEnd()
6712 
    iprot.readStructEnd()
6713 
 
6714 
  def write(self, oprot):
6715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6717 
      return
6718 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 6719 
    if self.id is not None:
94 ashish 6720 
      oprot.writeFieldBegin('id', TType.I64, 1)
6721 
      oprot.writeI64(self.id)
6722 
      oprot.writeFieldEnd()
6723 
    oprot.writeFieldStop()
6724 
    oprot.writeStructEnd()
6725 
 
3431 rajveer 6726 
  def validate(self):
6727 
    return
6728 
 
6729 
 
94 ashish 6730 
  def __repr__(self):
6731 
    L = ['%s=%r' % (key, value)
6732 
      for key, value in self.__dict__.iteritems()]
6733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6734 
 
6735 
  def __eq__(self, other):
6736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6737 
 
6738 
  def __ne__(self, other):
6739 
    return not (self == other)
6740 
 
6741 
class getTransaction_result:
6742 
  """
6743 
  Attributes:
6744 
   - success
6745 
   - ex
6746 
  """
6747 
 
6748 
  thrift_spec = (
6749 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
6750 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6751 
  )
6752 
 
6753 
  def __init__(self, success=None, ex=None,):
6754 
    self.success = success
6755 
    self.ex = ex
6756 
 
6757 
  def read(self, iprot):
6758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6760 
      return
6761 
    iprot.readStructBegin()
6762 
    while True:
6763 
      (fname, ftype, fid) = iprot.readFieldBegin()
6764 
      if ftype == TType.STOP:
6765 
        break
6766 
      if fid == 0:
6767 
        if ftype == TType.STRUCT:
6768 
          self.success = Transaction()
6769 
          self.success.read(iprot)
6770 
        else:
6771 
          iprot.skip(ftype)
6772 
      elif fid == 1:
6773 
        if ftype == TType.STRUCT:
6774 
          self.ex = TransactionServiceException()
6775 
          self.ex.read(iprot)
6776 
        else:
6777 
          iprot.skip(ftype)
6778 
      else:
6779 
        iprot.skip(ftype)
6780 
      iprot.readFieldEnd()
6781 
    iprot.readStructEnd()
6782 
 
6783 
  def write(self, oprot):
6784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6786 
      return
6787 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 6788 
    if self.success is not None:
94 ashish 6789 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6790 
      self.success.write(oprot)
6791 
      oprot.writeFieldEnd()
3431 rajveer 6792 
    if self.ex is not None:
94 ashish 6793 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6794 
      self.ex.write(oprot)
6795 
      oprot.writeFieldEnd()
6796 
    oprot.writeFieldStop()
6797 
    oprot.writeStructEnd()
6798 
 
3431 rajveer 6799 
  def validate(self):
6800 
    return
6801 
 
6802 
 
94 ashish 6803 
  def __repr__(self):
6804 
    L = ['%s=%r' % (key, value)
6805 
      for key, value in self.__dict__.iteritems()]
6806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6807 
 
6808 
  def __eq__(self, other):
6809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6810 
 
6811 
  def __ne__(self, other):
6812 
    return not (self == other)
6813 
 
6814 
class getTransactionsForCustomer_args:
6815 
  """
6816 
  Attributes:
6817 
   - customerId
6818 
   - from_date
6819 
   - to_date
6820 
   - status
6821 
  """
6822 
 
6823 
  thrift_spec = (
6824 
    None, # 0
6825 
    (1, TType.I64, 'customerId', None, None, ), # 1
6826 
    (2, TType.I64, 'from_date', None, None, ), # 2
6827 
    (3, TType.I64, 'to_date', None, None, ), # 3
6828 
    (4, TType.I32, 'status', None, None, ), # 4
6829 
  )
6830 
 
6831 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
6832 
    self.customerId = customerId
6833 
    self.from_date = from_date
6834 
    self.to_date = to_date
6835 
    self.status = status
6836 
 
6837 
  def read(self, iprot):
6838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6840 
      return
6841 
    iprot.readStructBegin()
6842 
    while True:
6843 
      (fname, ftype, fid) = iprot.readFieldBegin()
6844 
      if ftype == TType.STOP:
6845 
        break
6846 
      if fid == 1:
6847 
        if ftype == TType.I64:
6848 
          self.customerId = iprot.readI64();
6849 
        else:
6850 
          iprot.skip(ftype)
6851 
      elif fid == 2:
6852 
        if ftype == TType.I64:
6853 
          self.from_date = iprot.readI64();
6854 
        else:
6855 
          iprot.skip(ftype)
6856 
      elif fid == 3:
6857 
        if ftype == TType.I64:
6858 
          self.to_date = iprot.readI64();
6859 
        else:
6860 
          iprot.skip(ftype)
6861 
      elif fid == 4:
6862 
        if ftype == TType.I32:
6863 
          self.status = iprot.readI32();
6864 
        else:
6865 
          iprot.skip(ftype)
6866 
      else:
6867 
        iprot.skip(ftype)
6868 
      iprot.readFieldEnd()
6869 
    iprot.readStructEnd()
6870 
 
6871 
  def write(self, oprot):
6872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6874 
      return
6875 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 6876 
    if self.customerId is not None:
94 ashish 6877 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6878 
      oprot.writeI64(self.customerId)
6879 
      oprot.writeFieldEnd()
3431 rajveer 6880 
    if self.from_date is not None:
94 ashish 6881 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6882 
      oprot.writeI64(self.from_date)
6883 
      oprot.writeFieldEnd()
3431 rajveer 6884 
    if self.to_date is not None:
94 ashish 6885 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6886 
      oprot.writeI64(self.to_date)
6887 
      oprot.writeFieldEnd()
3431 rajveer 6888 
    if self.status is not None:
94 ashish 6889 
      oprot.writeFieldBegin('status', TType.I32, 4)
6890 
      oprot.writeI32(self.status)
6891 
      oprot.writeFieldEnd()
6892 
    oprot.writeFieldStop()
6893 
    oprot.writeStructEnd()
6894 
 
3431 rajveer 6895 
  def validate(self):
6896 
    return
6897 
 
6898 
 
94 ashish 6899 
  def __repr__(self):
6900 
    L = ['%s=%r' % (key, value)
6901 
      for key, value in self.__dict__.iteritems()]
6902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6903 
 
6904 
  def __eq__(self, other):
6905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6906 
 
6907 
  def __ne__(self, other):
6908 
    return not (self == other)
6909 
 
6910 
class getTransactionsForCustomer_result:
6911 
  """
6912 
  Attributes:
6913 
   - success
6914 
   - ex
6915 
  """
6916 
 
6917 
  thrift_spec = (
6918 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6919 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6920 
  )
6921 
 
6922 
  def __init__(self, success=None, ex=None,):
6923 
    self.success = success
6924 
    self.ex = ex
6925 
 
6926 
  def read(self, iprot):
6927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6929 
      return
6930 
    iprot.readStructBegin()
6931 
    while True:
6932 
      (fname, ftype, fid) = iprot.readFieldBegin()
6933 
      if ftype == TType.STOP:
6934 
        break
6935 
      if fid == 0:
6936 
        if ftype == TType.LIST:
6937 
          self.success = []
5031 varun.gupt 6938 
          (_etype66, _size63) = iprot.readListBegin()
6939 
          for _i67 in xrange(_size63):
6940 
            _elem68 = Transaction()
6941 
            _elem68.read(iprot)
6942 
            self.success.append(_elem68)
94 ashish 6943 
          iprot.readListEnd()
6944 
        else:
6945 
          iprot.skip(ftype)
6946 
      elif fid == 1:
6947 
        if ftype == TType.STRUCT:
6948 
          self.ex = TransactionServiceException()
6949 
          self.ex.read(iprot)
6950 
        else:
6951 
          iprot.skip(ftype)
6952 
      else:
6953 
        iprot.skip(ftype)
6954 
      iprot.readFieldEnd()
6955 
    iprot.readStructEnd()
6956 
 
6957 
  def write(self, oprot):
6958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6960 
      return
6961 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 6962 
    if self.success is not None:
94 ashish 6963 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6964 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 6965 
      for iter69 in self.success:
6966 
        iter69.write(oprot)
94 ashish 6967 
      oprot.writeListEnd()
6968 
      oprot.writeFieldEnd()
3431 rajveer 6969 
    if self.ex is not None:
94 ashish 6970 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6971 
      self.ex.write(oprot)
6972 
      oprot.writeFieldEnd()
6973 
    oprot.writeFieldStop()
6974 
    oprot.writeStructEnd()
6975 
 
3431 rajveer 6976 
  def validate(self):
6977 
    return
6978 
 
6979 
 
94 ashish 6980 
  def __repr__(self):
6981 
    L = ['%s=%r' % (key, value)
6982 
      for key, value in self.__dict__.iteritems()]
6983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6984 
 
6985 
  def __eq__(self, other):
6986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6987 
 
6988 
  def __ne__(self, other):
6989 
    return not (self == other)
6990 
 
132 ashish 6991 
class getTransactionsForShoppingCartId_args:
6992 
  """
6993 
  Attributes:
6994 
   - shoppingCartId
6995 
  """
6996 
 
6997 
  thrift_spec = (
6998 
    None, # 0
6999 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
7000 
  )
7001 
 
7002 
  def __init__(self, shoppingCartId=None,):
7003 
    self.shoppingCartId = shoppingCartId
7004 
 
7005 
  def read(self, iprot):
7006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7008 
      return
7009 
    iprot.readStructBegin()
7010 
    while True:
7011 
      (fname, ftype, fid) = iprot.readFieldBegin()
7012 
      if ftype == TType.STOP:
7013 
        break
7014 
      if fid == 1:
7015 
        if ftype == TType.I64:
7016 
          self.shoppingCartId = iprot.readI64();
7017 
        else:
7018 
          iprot.skip(ftype)
7019 
      else:
7020 
        iprot.skip(ftype)
7021 
      iprot.readFieldEnd()
7022 
    iprot.readStructEnd()
7023 
 
7024 
  def write(self, oprot):
7025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7027 
      return
7028 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 7029 
    if self.shoppingCartId is not None:
132 ashish 7030 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
7031 
      oprot.writeI64(self.shoppingCartId)
7032 
      oprot.writeFieldEnd()
7033 
    oprot.writeFieldStop()
7034 
    oprot.writeStructEnd()
7035 
 
3431 rajveer 7036 
  def validate(self):
7037 
    return
7038 
 
7039 
 
132 ashish 7040 
  def __repr__(self):
7041 
    L = ['%s=%r' % (key, value)
7042 
      for key, value in self.__dict__.iteritems()]
7043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7044 
 
7045 
  def __eq__(self, other):
7046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7047 
 
7048 
  def __ne__(self, other):
7049 
    return not (self == other)
7050 
 
7051 
class getTransactionsForShoppingCartId_result:
7052 
  """
7053 
  Attributes:
7054 
   - success
7055 
   - ex
7056 
  """
7057 
 
7058 
  thrift_spec = (
7059 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7060 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7061 
  )
7062 
 
7063 
  def __init__(self, success=None, ex=None,):
7064 
    self.success = success
7065 
    self.ex = ex
7066 
 
7067 
  def read(self, iprot):
7068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7070 
      return
7071 
    iprot.readStructBegin()
7072 
    while True:
7073 
      (fname, ftype, fid) = iprot.readFieldBegin()
7074 
      if ftype == TType.STOP:
7075 
        break
7076 
      if fid == 0:
7077 
        if ftype == TType.LIST:
7078 
          self.success = []
5031 varun.gupt 7079 
          (_etype73, _size70) = iprot.readListBegin()
7080 
          for _i74 in xrange(_size70):
7081 
            _elem75 = Transaction()
7082 
            _elem75.read(iprot)
7083 
            self.success.append(_elem75)
132 ashish 7084 
          iprot.readListEnd()
7085 
        else:
7086 
          iprot.skip(ftype)
7087 
      elif fid == 1:
7088 
        if ftype == TType.STRUCT:
7089 
          self.ex = TransactionServiceException()
7090 
          self.ex.read(iprot)
7091 
        else:
7092 
          iprot.skip(ftype)
7093 
      else:
7094 
        iprot.skip(ftype)
7095 
      iprot.readFieldEnd()
7096 
    iprot.readStructEnd()
7097 
 
7098 
  def write(self, oprot):
7099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7101 
      return
7102 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 7103 
    if self.success is not None:
132 ashish 7104 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7105 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7106 
      for iter76 in self.success:
7107 
        iter76.write(oprot)
132 ashish 7108 
      oprot.writeListEnd()
7109 
      oprot.writeFieldEnd()
3431 rajveer 7110 
    if self.ex is not None:
132 ashish 7111 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7112 
      self.ex.write(oprot)
7113 
      oprot.writeFieldEnd()
7114 
    oprot.writeFieldStop()
7115 
    oprot.writeStructEnd()
7116 
 
3431 rajveer 7117 
  def validate(self):
7118 
    return
7119 
 
7120 
 
132 ashish 7121 
  def __repr__(self):
7122 
    L = ['%s=%r' % (key, value)
7123 
      for key, value in self.__dict__.iteritems()]
7124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7125 
 
7126 
  def __eq__(self, other):
7127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7128 
 
7129 
  def __ne__(self, other):
7130 
    return not (self == other)
7131 
 
94 ashish 7132 
class getTransactionStatus_args:
7133 
  """
7134 
  Attributes:
7135 
   - transactionId
7136 
  """
7137 
 
7138 
  thrift_spec = (
7139 
    None, # 0
7140 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7141 
  )
7142 
 
7143 
  def __init__(self, transactionId=None,):
7144 
    self.transactionId = transactionId
7145 
 
7146 
  def read(self, iprot):
7147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7149 
      return
7150 
    iprot.readStructBegin()
7151 
    while True:
7152 
      (fname, ftype, fid) = iprot.readFieldBegin()
7153 
      if ftype == TType.STOP:
7154 
        break
7155 
      if fid == 1:
7156 
        if ftype == TType.I64:
7157 
          self.transactionId = iprot.readI64();
7158 
        else:
7159 
          iprot.skip(ftype)
7160 
      else:
7161 
        iprot.skip(ftype)
7162 
      iprot.readFieldEnd()
7163 
    iprot.readStructEnd()
7164 
 
7165 
  def write(self, oprot):
7166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7168 
      return
7169 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 7170 
    if self.transactionId is not None:
94 ashish 7171 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7172 
      oprot.writeI64(self.transactionId)
7173 
      oprot.writeFieldEnd()
7174 
    oprot.writeFieldStop()
7175 
    oprot.writeStructEnd()
7176 
 
3431 rajveer 7177 
  def validate(self):
7178 
    return
7179 
 
7180 
 
94 ashish 7181 
  def __repr__(self):
7182 
    L = ['%s=%r' % (key, value)
7183 
      for key, value in self.__dict__.iteritems()]
7184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7185 
 
7186 
  def __eq__(self, other):
7187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7188 
 
7189 
  def __ne__(self, other):
7190 
    return not (self == other)
7191 
 
7192 
class getTransactionStatus_result:
7193 
  """
7194 
  Attributes:
7195 
   - success
7196 
   - ex
7197 
  """
7198 
 
7199 
  thrift_spec = (
7200 
    (0, TType.I32, 'success', None, None, ), # 0
7201 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7202 
  )
7203 
 
7204 
  def __init__(self, success=None, ex=None,):
7205 
    self.success = success
7206 
    self.ex = ex
7207 
 
7208 
  def read(self, iprot):
7209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7211 
      return
7212 
    iprot.readStructBegin()
7213 
    while True:
7214 
      (fname, ftype, fid) = iprot.readFieldBegin()
7215 
      if ftype == TType.STOP:
7216 
        break
7217 
      if fid == 0:
7218 
        if ftype == TType.I32:
7219 
          self.success = iprot.readI32();
7220 
        else:
7221 
          iprot.skip(ftype)
7222 
      elif fid == 1:
7223 
        if ftype == TType.STRUCT:
7224 
          self.ex = TransactionServiceException()
7225 
          self.ex.read(iprot)
7226 
        else:
7227 
          iprot.skip(ftype)
7228 
      else:
7229 
        iprot.skip(ftype)
7230 
      iprot.readFieldEnd()
7231 
    iprot.readStructEnd()
7232 
 
7233 
  def write(self, oprot):
7234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7236 
      return
7237 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 7238 
    if self.success is not None:
94 ashish 7239 
      oprot.writeFieldBegin('success', TType.I32, 0)
7240 
      oprot.writeI32(self.success)
7241 
      oprot.writeFieldEnd()
3431 rajveer 7242 
    if self.ex is not None:
94 ashish 7243 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7244 
      self.ex.write(oprot)
7245 
      oprot.writeFieldEnd()
7246 
    oprot.writeFieldStop()
7247 
    oprot.writeStructEnd()
7248 
 
3431 rajveer 7249 
  def validate(self):
7250 
    return
7251 
 
7252 
 
94 ashish 7253 
  def __repr__(self):
7254 
    L = ['%s=%r' % (key, value)
7255 
      for key, value in self.__dict__.iteritems()]
7256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7257 
 
7258 
  def __eq__(self, other):
7259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7260 
 
7261 
  def __ne__(self, other):
7262 
    return not (self == other)
7263 
 
7264 
class changeTransactionStatus_args:
7265 
  """
7266 
  Attributes:
7267 
   - transactionId
7268 
   - status
7269 
   - description
7270 
  """
7271 
 
7272 
  thrift_spec = (
7273 
    None, # 0
7274 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7275 
    (2, TType.I32, 'status', None, None, ), # 2
7276 
    (3, TType.STRING, 'description', None, None, ), # 3
7277 
  )
7278 
 
7279 
  def __init__(self, transactionId=None, status=None, description=None,):
7280 
    self.transactionId = transactionId
7281 
    self.status = status
7282 
    self.description = description
7283 
 
7284 
  def read(self, iprot):
7285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7287 
      return
7288 
    iprot.readStructBegin()
7289 
    while True:
7290 
      (fname, ftype, fid) = iprot.readFieldBegin()
7291 
      if ftype == TType.STOP:
7292 
        break
7293 
      if fid == 1:
7294 
        if ftype == TType.I64:
7295 
          self.transactionId = iprot.readI64();
7296 
        else:
7297 
          iprot.skip(ftype)
7298 
      elif fid == 2:
7299 
        if ftype == TType.I32:
7300 
          self.status = iprot.readI32();
7301 
        else:
7302 
          iprot.skip(ftype)
7303 
      elif fid == 3:
7304 
        if ftype == TType.STRING:
7305 
          self.description = iprot.readString();
7306 
        else:
7307 
          iprot.skip(ftype)
7308 
      else:
7309 
        iprot.skip(ftype)
7310 
      iprot.readFieldEnd()
7311 
    iprot.readStructEnd()
7312 
 
7313 
  def write(self, oprot):
7314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7316 
      return
7317 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 7318 
    if self.transactionId is not None:
94 ashish 7319 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7320 
      oprot.writeI64(self.transactionId)
7321 
      oprot.writeFieldEnd()
3431 rajveer 7322 
    if self.status is not None:
94 ashish 7323 
      oprot.writeFieldBegin('status', TType.I32, 2)
7324 
      oprot.writeI32(self.status)
7325 
      oprot.writeFieldEnd()
3431 rajveer 7326 
    if self.description is not None:
94 ashish 7327 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7328 
      oprot.writeString(self.description)
7329 
      oprot.writeFieldEnd()
7330 
    oprot.writeFieldStop()
7331 
    oprot.writeStructEnd()
7332 
 
3431 rajveer 7333 
  def validate(self):
7334 
    return
7335 
 
7336 
 
94 ashish 7337 
  def __repr__(self):
7338 
    L = ['%s=%r' % (key, value)
7339 
      for key, value in self.__dict__.iteritems()]
7340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7341 
 
7342 
  def __eq__(self, other):
7343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7344 
 
7345 
  def __ne__(self, other):
7346 
    return not (self == other)
7347 
 
7348 
class changeTransactionStatus_result:
7349 
  """
7350 
  Attributes:
7351 
   - success
7352 
   - ex
7353 
  """
7354 
 
7355 
  thrift_spec = (
7356 
    (0, TType.BOOL, 'success', None, None, ), # 0
7357 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7358 
  )
7359 
 
7360 
  def __init__(self, success=None, ex=None,):
7361 
    self.success = success
7362 
    self.ex = ex
7363 
 
7364 
  def read(self, iprot):
7365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7367 
      return
7368 
    iprot.readStructBegin()
7369 
    while True:
7370 
      (fname, ftype, fid) = iprot.readFieldBegin()
7371 
      if ftype == TType.STOP:
7372 
        break
7373 
      if fid == 0:
7374 
        if ftype == TType.BOOL:
7375 
          self.success = iprot.readBool();
7376 
        else:
7377 
          iprot.skip(ftype)
7378 
      elif fid == 1:
7379 
        if ftype == TType.STRUCT:
7380 
          self.ex = TransactionServiceException()
7381 
          self.ex.read(iprot)
7382 
        else:
7383 
          iprot.skip(ftype)
7384 
      else:
7385 
        iprot.skip(ftype)
7386 
      iprot.readFieldEnd()
7387 
    iprot.readStructEnd()
7388 
 
7389 
  def write(self, oprot):
7390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7392 
      return
7393 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 7394 
    if self.success is not None:
94 ashish 7395 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7396 
      oprot.writeBool(self.success)
7397 
      oprot.writeFieldEnd()
3431 rajveer 7398 
    if self.ex is not None:
94 ashish 7399 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7400 
      self.ex.write(oprot)
7401 
      oprot.writeFieldEnd()
7402 
    oprot.writeFieldStop()
7403 
    oprot.writeStructEnd()
7404 
 
3431 rajveer 7405 
  def validate(self):
7406 
    return
7407 
 
7408 
 
94 ashish 7409 
  def __repr__(self):
7410 
    L = ['%s=%r' % (key, value)
7411 
      for key, value in self.__dict__.iteritems()]
7412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7413 
 
7414 
  def __eq__(self, other):
7415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7416 
 
7417 
  def __ne__(self, other):
7418 
    return not (self == other)
7419 
 
1398 varun.gupt 7420 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 7421 
  """
7422 
  Attributes:
7423 
   - transactionId
7424 
  """
7425 
 
7426 
  thrift_spec = (
7427 
    None, # 0
7428 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7429 
  )
7430 
 
7431 
  def __init__(self, transactionId=None,):
7432 
    self.transactionId = transactionId
7433 
 
7434 
  def read(self, iprot):
7435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7437 
      return
7438 
    iprot.readStructBegin()
7439 
    while True:
7440 
      (fname, ftype, fid) = iprot.readFieldBegin()
7441 
      if ftype == TType.STOP:
7442 
        break
7443 
      if fid == 1:
7444 
        if ftype == TType.I64:
7445 
          self.transactionId = iprot.readI64();
7446 
        else:
7447 
          iprot.skip(ftype)
7448 
      else:
7449 
        iprot.skip(ftype)
7450 
      iprot.readFieldEnd()
7451 
    iprot.readStructEnd()
7452 
 
7453 
  def write(self, oprot):
7454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7456 
      return
1398 varun.gupt 7457 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 7458 
    if self.transactionId is not None:
1382 varun.gupt 7459 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7460 
      oprot.writeI64(self.transactionId)
7461 
      oprot.writeFieldEnd()
7462 
    oprot.writeFieldStop()
7463 
    oprot.writeStructEnd()
7464 
 
3431 rajveer 7465 
  def validate(self):
7466 
    return
7467 
 
7468 
 
1382 varun.gupt 7469 
  def __repr__(self):
7470 
    L = ['%s=%r' % (key, value)
7471 
      for key, value in self.__dict__.iteritems()]
7472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7473 
 
7474 
  def __eq__(self, other):
7475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7476 
 
7477 
  def __ne__(self, other):
7478 
    return not (self == other)
7479 
 
1398 varun.gupt 7480 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 7481 
  """
7482 
  Attributes:
7483 
   - success
7484 
   - ex
7485 
  """
7486 
 
7487 
  thrift_spec = (
7488 
    (0, TType.BOOL, 'success', None, None, ), # 0
7489 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7490 
  )
7491 
 
7492 
  def __init__(self, success=None, ex=None,):
7493 
    self.success = success
7494 
    self.ex = ex
7495 
 
7496 
  def read(self, iprot):
7497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7499 
      return
7500 
    iprot.readStructBegin()
7501 
    while True:
7502 
      (fname, ftype, fid) = iprot.readFieldBegin()
7503 
      if ftype == TType.STOP:
7504 
        break
7505 
      if fid == 0:
7506 
        if ftype == TType.BOOL:
7507 
          self.success = iprot.readBool();
7508 
        else:
7509 
          iprot.skip(ftype)
7510 
      elif fid == 1:
7511 
        if ftype == TType.STRUCT:
7512 
          self.ex = TransactionServiceException()
7513 
          self.ex.read(iprot)
7514 
        else:
7515 
          iprot.skip(ftype)
7516 
      else:
7517 
        iprot.skip(ftype)
7518 
      iprot.readFieldEnd()
7519 
    iprot.readStructEnd()
7520 
 
7521 
  def write(self, oprot):
7522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7524 
      return
1398 varun.gupt 7525 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 7526 
    if self.success is not None:
1382 varun.gupt 7527 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7528 
      oprot.writeBool(self.success)
7529 
      oprot.writeFieldEnd()
3431 rajveer 7530 
    if self.ex is not None:
1382 varun.gupt 7531 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7532 
      self.ex.write(oprot)
7533 
      oprot.writeFieldEnd()
7534 
    oprot.writeFieldStop()
7535 
    oprot.writeStructEnd()
7536 
 
3431 rajveer 7537 
  def validate(self):
7538 
    return
7539 
 
7540 
 
1382 varun.gupt 7541 
  def __repr__(self):
7542 
    L = ['%s=%r' % (key, value)
7543 
      for key, value in self.__dict__.iteritems()]
7544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7545 
 
7546 
  def __eq__(self, other):
7547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7548 
 
7549 
  def __ne__(self, other):
7550 
    return not (self == other)
7551 
 
483 rajveer 7552 
class getAllOrders_args:
94 ashish 7553 
  """
7554 
  Attributes:
4801 anupam.sin 7555 
   - statuses
483 rajveer 7556 
   - from_date
7557 
   - to_date
7558 
   - warehouse_id
94 ashish 7559 
  """
7560 
 
7561 
  thrift_spec = (
7562 
    None, # 0
4801 anupam.sin 7563 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 7564 
    (2, TType.I64, 'from_date', None, None, ), # 2
7565 
    (3, TType.I64, 'to_date', None, None, ), # 3
7566 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 7567 
  )
7568 
 
4801 anupam.sin 7569 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
7570 
    self.statuses = statuses
483 rajveer 7571 
    self.from_date = from_date
7572 
    self.to_date = to_date
7573 
    self.warehouse_id = warehouse_id
94 ashish 7574 
 
7575 
  def read(self, iprot):
7576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7578 
      return
7579 
    iprot.readStructBegin()
7580 
    while True:
7581 
      (fname, ftype, fid) = iprot.readFieldBegin()
7582 
      if ftype == TType.STOP:
7583 
        break
7584 
      if fid == 1:
4801 anupam.sin 7585 
        if ftype == TType.LIST:
7586 
          self.statuses = []
5031 varun.gupt 7587 
          (_etype80, _size77) = iprot.readListBegin()
7588 
          for _i81 in xrange(_size77):
7589 
            _elem82 = iprot.readI32();
7590 
            self.statuses.append(_elem82)
4801 anupam.sin 7591 
          iprot.readListEnd()
94 ashish 7592 
        else:
7593 
          iprot.skip(ftype)
483 rajveer 7594 
      elif fid == 2:
7595 
        if ftype == TType.I64:
7596 
          self.from_date = iprot.readI64();
94 ashish 7597 
        else:
7598 
          iprot.skip(ftype)
483 rajveer 7599 
      elif fid == 3:
7600 
        if ftype == TType.I64:
7601 
          self.to_date = iprot.readI64();
94 ashish 7602 
        else:
7603 
          iprot.skip(ftype)
483 rajveer 7604 
      elif fid == 4:
94 ashish 7605 
        if ftype == TType.I64:
483 rajveer 7606 
          self.warehouse_id = iprot.readI64();
94 ashish 7607 
        else:
7608 
          iprot.skip(ftype)
7609 
      else:
7610 
        iprot.skip(ftype)
7611 
      iprot.readFieldEnd()
7612 
    iprot.readStructEnd()
7613 
 
7614 
  def write(self, oprot):
7615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7617 
      return
483 rajveer 7618 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 7619 
    if self.statuses is not None:
7620 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7621 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7622 
      for iter83 in self.statuses:
7623 
        oprot.writeI32(iter83)
4801 anupam.sin 7624 
      oprot.writeListEnd()
94 ashish 7625 
      oprot.writeFieldEnd()
3431 rajveer 7626 
    if self.from_date is not None:
483 rajveer 7627 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7628 
      oprot.writeI64(self.from_date)
94 ashish 7629 
      oprot.writeFieldEnd()
3431 rajveer 7630 
    if self.to_date is not None:
483 rajveer 7631 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7632 
      oprot.writeI64(self.to_date)
94 ashish 7633 
      oprot.writeFieldEnd()
3431 rajveer 7634 
    if self.warehouse_id is not None:
483 rajveer 7635 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7636 
      oprot.writeI64(self.warehouse_id)
94 ashish 7637 
      oprot.writeFieldEnd()
7638 
    oprot.writeFieldStop()
7639 
    oprot.writeStructEnd()
7640 
 
3431 rajveer 7641 
  def validate(self):
7642 
    return
7643 
 
7644 
 
94 ashish 7645 
  def __repr__(self):
7646 
    L = ['%s=%r' % (key, value)
7647 
      for key, value in self.__dict__.iteritems()]
7648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7649 
 
7650 
  def __eq__(self, other):
7651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7652 
 
7653 
  def __ne__(self, other):
7654 
    return not (self == other)
7655 
 
483 rajveer 7656 
class getAllOrders_result:
94 ashish 7657 
  """
7658 
  Attributes:
7659 
   - success
7660 
   - ex
7661 
  """
7662 
 
7663 
  thrift_spec = (
483 rajveer 7664 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 7665 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7666 
  )
7667 
 
7668 
  def __init__(self, success=None, ex=None,):
7669 
    self.success = success
7670 
    self.ex = ex
7671 
 
7672 
  def read(self, iprot):
7673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7675 
      return
7676 
    iprot.readStructBegin()
7677 
    while True:
7678 
      (fname, ftype, fid) = iprot.readFieldBegin()
7679 
      if ftype == TType.STOP:
7680 
        break
7681 
      if fid == 0:
483 rajveer 7682 
        if ftype == TType.LIST:
7683 
          self.success = []
5031 varun.gupt 7684 
          (_etype87, _size84) = iprot.readListBegin()
7685 
          for _i88 in xrange(_size84):
7686 
            _elem89 = Order()
7687 
            _elem89.read(iprot)
7688 
            self.success.append(_elem89)
483 rajveer 7689 
          iprot.readListEnd()
94 ashish 7690 
        else:
7691 
          iprot.skip(ftype)
7692 
      elif fid == 1:
7693 
        if ftype == TType.STRUCT:
7694 
          self.ex = TransactionServiceException()
7695 
          self.ex.read(iprot)
7696 
        else:
7697 
          iprot.skip(ftype)
7698 
      else:
7699 
        iprot.skip(ftype)
7700 
      iprot.readFieldEnd()
7701 
    iprot.readStructEnd()
7702 
 
7703 
  def write(self, oprot):
7704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7706 
      return
483 rajveer 7707 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 7708 
    if self.success is not None:
483 rajveer 7709 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7710 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7711 
      for iter90 in self.success:
7712 
        iter90.write(oprot)
483 rajveer 7713 
      oprot.writeListEnd()
94 ashish 7714 
      oprot.writeFieldEnd()
3431 rajveer 7715 
    if self.ex is not None:
94 ashish 7716 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7717 
      self.ex.write(oprot)
7718 
      oprot.writeFieldEnd()
7719 
    oprot.writeFieldStop()
7720 
    oprot.writeStructEnd()
7721 
 
3431 rajveer 7722 
  def validate(self):
7723 
    return
7724 
 
7725 
 
94 ashish 7726 
  def __repr__(self):
7727 
    L = ['%s=%r' % (key, value)
7728 
      for key, value in self.__dict__.iteritems()]
7729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7730 
 
7731 
  def __eq__(self, other):
7732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7733 
 
7734 
  def __ne__(self, other):
7735 
    return not (self == other)
7736 
 
4133 chandransh 7737 
class getOrdersInBatch_args:
7738 
  """
7739 
  Attributes:
7740 
   - statuses
7741 
   - offset
7742 
   - limit
7743 
   - warehouse_id
7744 
  """
7745 
 
7746 
  thrift_spec = (
7747 
    None, # 0
7748 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7749 
    (2, TType.I64, 'offset', None, None, ), # 2
7750 
    (3, TType.I64, 'limit', None, None, ), # 3
7751 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7752 
  )
7753 
 
7754 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
7755 
    self.statuses = statuses
7756 
    self.offset = offset
7757 
    self.limit = limit
7758 
    self.warehouse_id = warehouse_id
7759 
 
7760 
  def read(self, iprot):
7761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7763 
      return
7764 
    iprot.readStructBegin()
7765 
    while True:
7766 
      (fname, ftype, fid) = iprot.readFieldBegin()
7767 
      if ftype == TType.STOP:
7768 
        break
7769 
      if fid == 1:
7770 
        if ftype == TType.LIST:
7771 
          self.statuses = []
5031 varun.gupt 7772 
          (_etype94, _size91) = iprot.readListBegin()
7773 
          for _i95 in xrange(_size91):
7774 
            _elem96 = iprot.readI32();
7775 
            self.statuses.append(_elem96)
4133 chandransh 7776 
          iprot.readListEnd()
7777 
        else:
7778 
          iprot.skip(ftype)
7779 
      elif fid == 2:
7780 
        if ftype == TType.I64:
7781 
          self.offset = iprot.readI64();
7782 
        else:
7783 
          iprot.skip(ftype)
7784 
      elif fid == 3:
7785 
        if ftype == TType.I64:
7786 
          self.limit = iprot.readI64();
7787 
        else:
7788 
          iprot.skip(ftype)
7789 
      elif fid == 4:
7790 
        if ftype == TType.I64:
7791 
          self.warehouse_id = iprot.readI64();
7792 
        else:
7793 
          iprot.skip(ftype)
7794 
      else:
7795 
        iprot.skip(ftype)
7796 
      iprot.readFieldEnd()
7797 
    iprot.readStructEnd()
7798 
 
7799 
  def write(self, oprot):
7800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7802 
      return
7803 
    oprot.writeStructBegin('getOrdersInBatch_args')
7804 
    if self.statuses is not None:
7805 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7806 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7807 
      for iter97 in self.statuses:
7808 
        oprot.writeI32(iter97)
4133 chandransh 7809 
      oprot.writeListEnd()
7810 
      oprot.writeFieldEnd()
7811 
    if self.offset is not None:
7812 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7813 
      oprot.writeI64(self.offset)
7814 
      oprot.writeFieldEnd()
7815 
    if self.limit is not None:
7816 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7817 
      oprot.writeI64(self.limit)
7818 
      oprot.writeFieldEnd()
7819 
    if self.warehouse_id is not None:
7820 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7821 
      oprot.writeI64(self.warehouse_id)
7822 
      oprot.writeFieldEnd()
7823 
    oprot.writeFieldStop()
7824 
    oprot.writeStructEnd()
7825 
 
7826 
  def validate(self):
7827 
    return
7828 
 
7829 
 
7830 
  def __repr__(self):
7831 
    L = ['%s=%r' % (key, value)
7832 
      for key, value in self.__dict__.iteritems()]
7833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7834 
 
7835 
  def __eq__(self, other):
7836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7837 
 
7838 
  def __ne__(self, other):
7839 
    return not (self == other)
7840 
 
7841 
class getOrdersInBatch_result:
7842 
  """
7843 
  Attributes:
7844 
   - success
7845 
   - ex
7846 
  """
7847 
 
7848 
  thrift_spec = (
7849 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7850 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7851 
  )
7852 
 
7853 
  def __init__(self, success=None, ex=None,):
7854 
    self.success = success
7855 
    self.ex = ex
7856 
 
7857 
  def read(self, iprot):
7858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7860 
      return
7861 
    iprot.readStructBegin()
7862 
    while True:
7863 
      (fname, ftype, fid) = iprot.readFieldBegin()
7864 
      if ftype == TType.STOP:
7865 
        break
7866 
      if fid == 0:
7867 
        if ftype == TType.LIST:
7868 
          self.success = []
5031 varun.gupt 7869 
          (_etype101, _size98) = iprot.readListBegin()
7870 
          for _i102 in xrange(_size98):
7871 
            _elem103 = Order()
7872 
            _elem103.read(iprot)
7873 
            self.success.append(_elem103)
4133 chandransh 7874 
          iprot.readListEnd()
7875 
        else:
7876 
          iprot.skip(ftype)
7877 
      elif fid == 1:
7878 
        if ftype == TType.STRUCT:
7879 
          self.ex = TransactionServiceException()
7880 
          self.ex.read(iprot)
7881 
        else:
7882 
          iprot.skip(ftype)
7883 
      else:
7884 
        iprot.skip(ftype)
7885 
      iprot.readFieldEnd()
7886 
    iprot.readStructEnd()
7887 
 
7888 
  def write(self, oprot):
7889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7891 
      return
7892 
    oprot.writeStructBegin('getOrdersInBatch_result')
7893 
    if self.success is not None:
7894 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7895 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7896 
      for iter104 in self.success:
7897 
        iter104.write(oprot)
4133 chandransh 7898 
      oprot.writeListEnd()
7899 
      oprot.writeFieldEnd()
7900 
    if self.ex is not None:
7901 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7902 
      self.ex.write(oprot)
7903 
      oprot.writeFieldEnd()
7904 
    oprot.writeFieldStop()
7905 
    oprot.writeStructEnd()
7906 
 
7907 
  def validate(self):
7908 
    return
7909 
 
7910 
 
7911 
  def __repr__(self):
7912 
    L = ['%s=%r' % (key, value)
7913 
      for key, value in self.__dict__.iteritems()]
7914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7915 
 
7916 
  def __eq__(self, other):
7917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7918 
 
7919 
  def __ne__(self, other):
7920 
    return not (self == other)
7921 
 
7922 
class getOrderCount_args:
7923 
  """
7924 
  Attributes:
7925 
   - statuses
7926 
   - warehouseId
7927 
  """
7928 
 
7929 
  thrift_spec = (
7930 
    None, # 0
7931 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7932 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7933 
  )
7934 
 
7935 
  def __init__(self, statuses=None, warehouseId=None,):
7936 
    self.statuses = statuses
7937 
    self.warehouseId = warehouseId
7938 
 
7939 
  def read(self, iprot):
7940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7942 
      return
7943 
    iprot.readStructBegin()
7944 
    while True:
7945 
      (fname, ftype, fid) = iprot.readFieldBegin()
7946 
      if ftype == TType.STOP:
7947 
        break
7948 
      if fid == 1:
7949 
        if ftype == TType.LIST:
7950 
          self.statuses = []
5031 varun.gupt 7951 
          (_etype108, _size105) = iprot.readListBegin()
7952 
          for _i109 in xrange(_size105):
7953 
            _elem110 = iprot.readI32();
7954 
            self.statuses.append(_elem110)
4133 chandransh 7955 
          iprot.readListEnd()
7956 
        else:
7957 
          iprot.skip(ftype)
7958 
      elif fid == 2:
7959 
        if ftype == TType.I64:
7960 
          self.warehouseId = iprot.readI64();
7961 
        else:
7962 
          iprot.skip(ftype)
7963 
      else:
7964 
        iprot.skip(ftype)
7965 
      iprot.readFieldEnd()
7966 
    iprot.readStructEnd()
7967 
 
7968 
  def write(self, oprot):
7969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7971 
      return
7972 
    oprot.writeStructBegin('getOrderCount_args')
7973 
    if self.statuses is not None:
7974 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7975 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7976 
      for iter111 in self.statuses:
7977 
        oprot.writeI32(iter111)
4133 chandransh 7978 
      oprot.writeListEnd()
7979 
      oprot.writeFieldEnd()
7980 
    if self.warehouseId is not None:
7981 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7982 
      oprot.writeI64(self.warehouseId)
7983 
      oprot.writeFieldEnd()
7984 
    oprot.writeFieldStop()
7985 
    oprot.writeStructEnd()
7986 
 
7987 
  def validate(self):
7988 
    return
7989 
 
7990 
 
7991 
  def __repr__(self):
7992 
    L = ['%s=%r' % (key, value)
7993 
      for key, value in self.__dict__.iteritems()]
7994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7995 
 
7996 
  def __eq__(self, other):
7997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7998 
 
7999 
  def __ne__(self, other):
8000 
    return not (self == other)
8001 
 
8002 
class getOrderCount_result:
8003 
  """
8004 
  Attributes:
8005 
   - success
8006 
   - ex
8007 
  """
8008 
 
8009 
  thrift_spec = (
8010 
    (0, TType.I32, 'success', None, None, ), # 0
8011 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8012 
  )
8013 
 
8014 
  def __init__(self, success=None, ex=None,):
8015 
    self.success = success
8016 
    self.ex = ex
8017 
 
8018 
  def read(self, iprot):
8019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8021 
      return
8022 
    iprot.readStructBegin()
8023 
    while True:
8024 
      (fname, ftype, fid) = iprot.readFieldBegin()
8025 
      if ftype == TType.STOP:
8026 
        break
8027 
      if fid == 0:
8028 
        if ftype == TType.I32:
8029 
          self.success = iprot.readI32();
8030 
        else:
8031 
          iprot.skip(ftype)
8032 
      elif fid == 1:
8033 
        if ftype == TType.STRUCT:
8034 
          self.ex = TransactionServiceException()
8035 
          self.ex.read(iprot)
8036 
        else:
8037 
          iprot.skip(ftype)
8038 
      else:
8039 
        iprot.skip(ftype)
8040 
      iprot.readFieldEnd()
8041 
    iprot.readStructEnd()
8042 
 
8043 
  def write(self, oprot):
8044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8046 
      return
8047 
    oprot.writeStructBegin('getOrderCount_result')
8048 
    if self.success is not None:
8049 
      oprot.writeFieldBegin('success', TType.I32, 0)
8050 
      oprot.writeI32(self.success)
8051 
      oprot.writeFieldEnd()
8052 
    if self.ex is not None:
8053 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8054 
      self.ex.write(oprot)
8055 
      oprot.writeFieldEnd()
8056 
    oprot.writeFieldStop()
8057 
    oprot.writeStructEnd()
8058 
 
8059 
  def validate(self):
8060 
    return
8061 
 
8062 
 
8063 
  def __repr__(self):
8064 
    L = ['%s=%r' % (key, value)
8065 
      for key, value in self.__dict__.iteritems()]
8066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8067 
 
8068 
  def __eq__(self, other):
8069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8070 
 
8071 
  def __ne__(self, other):
8072 
    return not (self == other)
8073 
 
999 varun.gupt 8074 
class getOrdersByBillingDate_args:
8075 
  """
8076 
  Attributes:
8077 
   - status
8078 
   - start_billing_date
8079 
   - end_billing_date
8080 
   - warehouse_id
8081 
  """
8082 
 
8083 
  thrift_spec = (
8084 
    None, # 0
8085 
    (1, TType.I32, 'status', None, None, ), # 1
8086 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
8087 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
8088 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8089 
  )
8090 
 
8091 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
8092 
    self.status = status
8093 
    self.start_billing_date = start_billing_date
8094 
    self.end_billing_date = end_billing_date
8095 
    self.warehouse_id = warehouse_id
8096 
 
8097 
  def read(self, iprot):
8098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8100 
      return
8101 
    iprot.readStructBegin()
8102 
    while True:
8103 
      (fname, ftype, fid) = iprot.readFieldBegin()
8104 
      if ftype == TType.STOP:
8105 
        break
8106 
      if fid == 1:
8107 
        if ftype == TType.I32:
8108 
          self.status = iprot.readI32();
8109 
        else:
8110 
          iprot.skip(ftype)
8111 
      elif fid == 2:
8112 
        if ftype == TType.I64:
8113 
          self.start_billing_date = iprot.readI64();
8114 
        else:
8115 
          iprot.skip(ftype)
8116 
      elif fid == 3:
8117 
        if ftype == TType.I64:
8118 
          self.end_billing_date = iprot.readI64();
8119 
        else:
8120 
          iprot.skip(ftype)
8121 
      elif fid == 4:
8122 
        if ftype == TType.I64:
8123 
          self.warehouse_id = iprot.readI64();
8124 
        else:
8125 
          iprot.skip(ftype)
8126 
      else:
8127 
        iprot.skip(ftype)
8128 
      iprot.readFieldEnd()
8129 
    iprot.readStructEnd()
8130 
 
8131 
  def write(self, oprot):
8132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8134 
      return
8135 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 8136 
    if self.status is not None:
999 varun.gupt 8137 
      oprot.writeFieldBegin('status', TType.I32, 1)
8138 
      oprot.writeI32(self.status)
8139 
      oprot.writeFieldEnd()
3431 rajveer 8140 
    if self.start_billing_date is not None:
999 varun.gupt 8141 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
8142 
      oprot.writeI64(self.start_billing_date)
8143 
      oprot.writeFieldEnd()
3431 rajveer 8144 
    if self.end_billing_date is not None:
999 varun.gupt 8145 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
8146 
      oprot.writeI64(self.end_billing_date)
8147 
      oprot.writeFieldEnd()
3431 rajveer 8148 
    if self.warehouse_id is not None:
999 varun.gupt 8149 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8150 
      oprot.writeI64(self.warehouse_id)
8151 
      oprot.writeFieldEnd()
8152 
    oprot.writeFieldStop()
8153 
    oprot.writeStructEnd()
8154 
 
3431 rajveer 8155 
  def validate(self):
8156 
    return
8157 
 
8158 
 
999 varun.gupt 8159 
  def __repr__(self):
8160 
    L = ['%s=%r' % (key, value)
8161 
      for key, value in self.__dict__.iteritems()]
8162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8163 
 
8164 
  def __eq__(self, other):
8165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8166 
 
8167 
  def __ne__(self, other):
8168 
    return not (self == other)
8169 
 
8170 
class getOrdersByBillingDate_result:
8171 
  """
8172 
  Attributes:
8173 
   - success
8174 
   - ex
8175 
  """
8176 
 
8177 
  thrift_spec = (
8178 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8179 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8180 
  )
8181 
 
8182 
  def __init__(self, success=None, ex=None,):
8183 
    self.success = success
8184 
    self.ex = ex
8185 
 
8186 
  def read(self, iprot):
8187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8189 
      return
8190 
    iprot.readStructBegin()
8191 
    while True:
8192 
      (fname, ftype, fid) = iprot.readFieldBegin()
8193 
      if ftype == TType.STOP:
8194 
        break
8195 
      if fid == 0:
8196 
        if ftype == TType.LIST:
8197 
          self.success = []
5031 varun.gupt 8198 
          (_etype115, _size112) = iprot.readListBegin()
8199 
          for _i116 in xrange(_size112):
8200 
            _elem117 = Order()
8201 
            _elem117.read(iprot)
8202 
            self.success.append(_elem117)
999 varun.gupt 8203 
          iprot.readListEnd()
8204 
        else:
8205 
          iprot.skip(ftype)
8206 
      elif fid == 1:
8207 
        if ftype == TType.STRUCT:
8208 
          self.ex = TransactionServiceException()
8209 
          self.ex.read(iprot)
8210 
        else:
8211 
          iprot.skip(ftype)
8212 
      else:
8213 
        iprot.skip(ftype)
8214 
      iprot.readFieldEnd()
8215 
    iprot.readStructEnd()
8216 
 
8217 
  def write(self, oprot):
8218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8220 
      return
8221 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 8222 
    if self.success is not None:
999 varun.gupt 8223 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8224 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8225 
      for iter118 in self.success:
8226 
        iter118.write(oprot)
999 varun.gupt 8227 
      oprot.writeListEnd()
8228 
      oprot.writeFieldEnd()
3431 rajveer 8229 
    if self.ex is not None:
999 varun.gupt 8230 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8231 
      self.ex.write(oprot)
8232 
      oprot.writeFieldEnd()
8233 
    oprot.writeFieldStop()
8234 
    oprot.writeStructEnd()
8235 
 
3431 rajveer 8236 
  def validate(self):
8237 
    return
8238 
 
8239 
 
999 varun.gupt 8240 
  def __repr__(self):
8241 
    L = ['%s=%r' % (key, value)
8242 
      for key, value in self.__dict__.iteritems()]
8243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8244 
 
8245 
  def __eq__(self, other):
8246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8247 
 
8248 
  def __ne__(self, other):
8249 
    return not (self == other)
8250 
 
3427 chandransh 8251 
class getOrdersByShippingDate_args:
8252 
  """
8253 
  Attributes:
8254 
   - fromShippingDate
8255 
   - toShippingDate
8256 
   - providerId
8257 
   - warehouseId
3451 chandransh 8258 
   - cod
3427 chandransh 8259 
  """
8260 
 
8261 
  thrift_spec = (
8262 
    None, # 0
8263 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
8264 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
8265 
    (3, TType.I64, 'providerId', None, None, ), # 3
8266 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 8267 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 8268 
  )
8269 
 
3451 chandransh 8270 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 8271 
    self.fromShippingDate = fromShippingDate
8272 
    self.toShippingDate = toShippingDate
8273 
    self.providerId = providerId
8274 
    self.warehouseId = warehouseId
3451 chandransh 8275 
    self.cod = cod
3427 chandransh 8276 
 
8277 
  def read(self, iprot):
8278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8280 
      return
8281 
    iprot.readStructBegin()
8282 
    while True:
8283 
      (fname, ftype, fid) = iprot.readFieldBegin()
8284 
      if ftype == TType.STOP:
8285 
        break
8286 
      if fid == 1:
8287 
        if ftype == TType.I64:
8288 
          self.fromShippingDate = iprot.readI64();
8289 
        else:
8290 
          iprot.skip(ftype)
8291 
      elif fid == 2:
8292 
        if ftype == TType.I64:
8293 
          self.toShippingDate = iprot.readI64();
8294 
        else:
8295 
          iprot.skip(ftype)
8296 
      elif fid == 3:
8297 
        if ftype == TType.I64:
8298 
          self.providerId = iprot.readI64();
8299 
        else:
8300 
          iprot.skip(ftype)
8301 
      elif fid == 4:
8302 
        if ftype == TType.I64:
8303 
          self.warehouseId = iprot.readI64();
8304 
        else:
8305 
          iprot.skip(ftype)
3451 chandransh 8306 
      elif fid == 5:
8307 
        if ftype == TType.BOOL:
8308 
          self.cod = iprot.readBool();
8309 
        else:
8310 
          iprot.skip(ftype)
3427 chandransh 8311 
      else:
8312 
        iprot.skip(ftype)
8313 
      iprot.readFieldEnd()
8314 
    iprot.readStructEnd()
8315 
 
8316 
  def write(self, oprot):
8317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8319 
      return
8320 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 8321 
    if self.fromShippingDate is not None:
3427 chandransh 8322 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
8323 
      oprot.writeI64(self.fromShippingDate)
8324 
      oprot.writeFieldEnd()
3431 rajveer 8325 
    if self.toShippingDate is not None:
3427 chandransh 8326 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
8327 
      oprot.writeI64(self.toShippingDate)
8328 
      oprot.writeFieldEnd()
3431 rajveer 8329 
    if self.providerId is not None:
3427 chandransh 8330 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
8331 
      oprot.writeI64(self.providerId)
8332 
      oprot.writeFieldEnd()
3431 rajveer 8333 
    if self.warehouseId is not None:
3427 chandransh 8334 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
8335 
      oprot.writeI64(self.warehouseId)
8336 
      oprot.writeFieldEnd()
3451 chandransh 8337 
    if self.cod is not None:
8338 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
8339 
      oprot.writeBool(self.cod)
8340 
      oprot.writeFieldEnd()
3427 chandransh 8341 
    oprot.writeFieldStop()
8342 
    oprot.writeStructEnd()
8343 
 
3431 rajveer 8344 
  def validate(self):
8345 
    return
8346 
 
8347 
 
3427 chandransh 8348 
  def __repr__(self):
8349 
    L = ['%s=%r' % (key, value)
8350 
      for key, value in self.__dict__.iteritems()]
8351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8352 
 
8353 
  def __eq__(self, other):
8354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8355 
 
8356 
  def __ne__(self, other):
8357 
    return not (self == other)
8358 
 
8359 
class getOrdersByShippingDate_result:
8360 
  """
8361 
  Attributes:
8362 
   - success
8363 
   - ex
8364 
  """
8365 
 
8366 
  thrift_spec = (
8367 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8368 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8369 
  )
8370 
 
8371 
  def __init__(self, success=None, ex=None,):
8372 
    self.success = success
8373 
    self.ex = ex
8374 
 
8375 
  def read(self, iprot):
8376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8378 
      return
8379 
    iprot.readStructBegin()
8380 
    while True:
8381 
      (fname, ftype, fid) = iprot.readFieldBegin()
8382 
      if ftype == TType.STOP:
8383 
        break
8384 
      if fid == 0:
8385 
        if ftype == TType.LIST:
8386 
          self.success = []
5031 varun.gupt 8387 
          (_etype122, _size119) = iprot.readListBegin()
8388 
          for _i123 in xrange(_size119):
8389 
            _elem124 = Order()
8390 
            _elem124.read(iprot)
8391 
            self.success.append(_elem124)
3427 chandransh 8392 
          iprot.readListEnd()
8393 
        else:
8394 
          iprot.skip(ftype)
8395 
      elif fid == 1:
8396 
        if ftype == TType.STRUCT:
8397 
          self.ex = TransactionServiceException()
8398 
          self.ex.read(iprot)
8399 
        else:
8400 
          iprot.skip(ftype)
8401 
      else:
8402 
        iprot.skip(ftype)
8403 
      iprot.readFieldEnd()
8404 
    iprot.readStructEnd()
8405 
 
8406 
  def write(self, oprot):
8407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8409 
      return
8410 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 8411 
    if self.success is not None:
3427 chandransh 8412 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8413 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8414 
      for iter125 in self.success:
8415 
        iter125.write(oprot)
3427 chandransh 8416 
      oprot.writeListEnd()
8417 
      oprot.writeFieldEnd()
3431 rajveer 8418 
    if self.ex is not None:
3427 chandransh 8419 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8420 
      self.ex.write(oprot)
8421 
      oprot.writeFieldEnd()
8422 
    oprot.writeFieldStop()
8423 
    oprot.writeStructEnd()
8424 
 
3431 rajveer 8425 
  def validate(self):
8426 
    return
8427 
 
8428 
 
3427 chandransh 8429 
  def __repr__(self):
8430 
    L = ['%s=%r' % (key, value)
8431 
      for key, value in self.__dict__.iteritems()]
8432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8433 
 
8434 
  def __eq__(self, other):
8435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8436 
 
8437 
  def __ne__(self, other):
8438 
    return not (self == other)
8439 
 
1382 varun.gupt 8440 
class getReturnableOrdersForCustomer_args:
8441 
  """
8442 
  Attributes:
8443 
   - customer_id
8444 
   - limit
8445 
  """
8446 
 
8447 
  thrift_spec = (
8448 
    None, # 0
8449 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8450 
    (2, TType.I64, 'limit', None, None, ), # 2
8451 
  )
8452 
 
8453 
  def __init__(self, customer_id=None, limit=None,):
8454 
    self.customer_id = customer_id
8455 
    self.limit = limit
8456 
 
8457 
  def read(self, iprot):
8458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8460 
      return
8461 
    iprot.readStructBegin()
8462 
    while True:
8463 
      (fname, ftype, fid) = iprot.readFieldBegin()
8464 
      if ftype == TType.STOP:
8465 
        break
8466 
      if fid == 1:
8467 
        if ftype == TType.I64:
8468 
          self.customer_id = iprot.readI64();
8469 
        else:
8470 
          iprot.skip(ftype)
8471 
      elif fid == 2:
8472 
        if ftype == TType.I64:
8473 
          self.limit = iprot.readI64();
8474 
        else:
8475 
          iprot.skip(ftype)
8476 
      else:
8477 
        iprot.skip(ftype)
8478 
      iprot.readFieldEnd()
8479 
    iprot.readStructEnd()
8480 
 
8481 
  def write(self, oprot):
8482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8484 
      return
8485 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 8486 
    if self.customer_id is not None:
1382 varun.gupt 8487 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8488 
      oprot.writeI64(self.customer_id)
8489 
      oprot.writeFieldEnd()
3431 rajveer 8490 
    if self.limit is not None:
1382 varun.gupt 8491 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8492 
      oprot.writeI64(self.limit)
8493 
      oprot.writeFieldEnd()
8494 
    oprot.writeFieldStop()
8495 
    oprot.writeStructEnd()
8496 
 
3431 rajveer 8497 
  def validate(self):
8498 
    return
8499 
 
8500 
 
1382 varun.gupt 8501 
  def __repr__(self):
8502 
    L = ['%s=%r' % (key, value)
8503 
      for key, value in self.__dict__.iteritems()]
8504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8505 
 
8506 
  def __eq__(self, other):
8507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8508 
 
8509 
  def __ne__(self, other):
8510 
    return not (self == other)
8511 
 
8512 
class getReturnableOrdersForCustomer_result:
8513 
  """
8514 
  Attributes:
8515 
   - success
8516 
   - ex
8517 
  """
8518 
 
8519 
  thrift_spec = (
8520 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8521 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8522 
  )
8523 
 
8524 
  def __init__(self, success=None, ex=None,):
8525 
    self.success = success
8526 
    self.ex = ex
8527 
 
8528 
  def read(self, iprot):
8529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8531 
      return
8532 
    iprot.readStructBegin()
8533 
    while True:
8534 
      (fname, ftype, fid) = iprot.readFieldBegin()
8535 
      if ftype == TType.STOP:
8536 
        break
8537 
      if fid == 0:
8538 
        if ftype == TType.LIST:
8539 
          self.success = []
5031 varun.gupt 8540 
          (_etype129, _size126) = iprot.readListBegin()
8541 
          for _i130 in xrange(_size126):
8542 
            _elem131 = iprot.readI64();
8543 
            self.success.append(_elem131)
1382 varun.gupt 8544 
          iprot.readListEnd()
8545 
        else:
8546 
          iprot.skip(ftype)
8547 
      elif fid == 1:
8548 
        if ftype == TType.STRUCT:
8549 
          self.ex = TransactionServiceException()
8550 
          self.ex.read(iprot)
8551 
        else:
8552 
          iprot.skip(ftype)
8553 
      else:
8554 
        iprot.skip(ftype)
8555 
      iprot.readFieldEnd()
8556 
    iprot.readStructEnd()
8557 
 
8558 
  def write(self, oprot):
8559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8561 
      return
8562 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 8563 
    if self.success is not None:
1382 varun.gupt 8564 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8565 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8566 
      for iter132 in self.success:
8567 
        oprot.writeI64(iter132)
1382 varun.gupt 8568 
      oprot.writeListEnd()
8569 
      oprot.writeFieldEnd()
3431 rajveer 8570 
    if self.ex is not None:
1382 varun.gupt 8571 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8572 
      self.ex.write(oprot)
8573 
      oprot.writeFieldEnd()
8574 
    oprot.writeFieldStop()
8575 
    oprot.writeStructEnd()
8576 
 
3431 rajveer 8577 
  def validate(self):
8578 
    return
8579 
 
8580 
 
1382 varun.gupt 8581 
  def __repr__(self):
8582 
    L = ['%s=%r' % (key, value)
8583 
      for key, value in self.__dict__.iteritems()]
8584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8585 
 
8586 
  def __eq__(self, other):
8587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8588 
 
8589 
  def __ne__(self, other):
8590 
    return not (self == other)
8591 
 
8592 
class getCancellableOrdersForCustomer_args:
8593 
  """
8594 
  Attributes:
8595 
   - customer_id
8596 
   - limit
8597 
  """
8598 
 
8599 
  thrift_spec = (
8600 
    None, # 0
8601 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8602 
    (2, TType.I64, 'limit', None, None, ), # 2
8603 
  )
8604 
 
8605 
  def __init__(self, customer_id=None, limit=None,):
8606 
    self.customer_id = customer_id
8607 
    self.limit = limit
8608 
 
8609 
  def read(self, iprot):
8610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8612 
      return
8613 
    iprot.readStructBegin()
8614 
    while True:
8615 
      (fname, ftype, fid) = iprot.readFieldBegin()
8616 
      if ftype == TType.STOP:
8617 
        break
8618 
      if fid == 1:
8619 
        if ftype == TType.I64:
8620 
          self.customer_id = iprot.readI64();
8621 
        else:
8622 
          iprot.skip(ftype)
8623 
      elif fid == 2:
8624 
        if ftype == TType.I64:
8625 
          self.limit = iprot.readI64();
8626 
        else:
8627 
          iprot.skip(ftype)
8628 
      else:
8629 
        iprot.skip(ftype)
8630 
      iprot.readFieldEnd()
8631 
    iprot.readStructEnd()
8632 
 
8633 
  def write(self, oprot):
8634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8636 
      return
8637 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 8638 
    if self.customer_id is not None:
1382 varun.gupt 8639 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8640 
      oprot.writeI64(self.customer_id)
8641 
      oprot.writeFieldEnd()
3431 rajveer 8642 
    if self.limit is not None:
1382 varun.gupt 8643 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8644 
      oprot.writeI64(self.limit)
8645 
      oprot.writeFieldEnd()
8646 
    oprot.writeFieldStop()
8647 
    oprot.writeStructEnd()
8648 
 
3431 rajveer 8649 
  def validate(self):
8650 
    return
8651 
 
8652 
 
1382 varun.gupt 8653 
  def __repr__(self):
8654 
    L = ['%s=%r' % (key, value)
8655 
      for key, value in self.__dict__.iteritems()]
8656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8657 
 
8658 
  def __eq__(self, other):
8659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8660 
 
8661 
  def __ne__(self, other):
8662 
    return not (self == other)
8663 
 
8664 
class getCancellableOrdersForCustomer_result:
8665 
  """
8666 
  Attributes:
8667 
   - success
8668 
   - ex
8669 
  """
8670 
 
8671 
  thrift_spec = (
8672 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8673 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8674 
  )
8675 
 
8676 
  def __init__(self, success=None, ex=None,):
8677 
    self.success = success
8678 
    self.ex = ex
8679 
 
8680 
  def read(self, iprot):
8681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8683 
      return
8684 
    iprot.readStructBegin()
8685 
    while True:
8686 
      (fname, ftype, fid) = iprot.readFieldBegin()
8687 
      if ftype == TType.STOP:
8688 
        break
8689 
      if fid == 0:
8690 
        if ftype == TType.LIST:
8691 
          self.success = []
5031 varun.gupt 8692 
          (_etype136, _size133) = iprot.readListBegin()
8693 
          for _i137 in xrange(_size133):
8694 
            _elem138 = iprot.readI64();
8695 
            self.success.append(_elem138)
1382 varun.gupt 8696 
          iprot.readListEnd()
8697 
        else:
8698 
          iprot.skip(ftype)
8699 
      elif fid == 1:
8700 
        if ftype == TType.STRUCT:
8701 
          self.ex = TransactionServiceException()
8702 
          self.ex.read(iprot)
8703 
        else:
8704 
          iprot.skip(ftype)
8705 
      else:
8706 
        iprot.skip(ftype)
8707 
      iprot.readFieldEnd()
8708 
    iprot.readStructEnd()
8709 
 
8710 
  def write(self, oprot):
8711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8713 
      return
8714 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 8715 
    if self.success is not None:
1382 varun.gupt 8716 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8717 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8718 
      for iter139 in self.success:
8719 
        oprot.writeI64(iter139)
1382 varun.gupt 8720 
      oprot.writeListEnd()
8721 
      oprot.writeFieldEnd()
3431 rajveer 8722 
    if self.ex is not None:
1382 varun.gupt 8723 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8724 
      self.ex.write(oprot)
8725 
      oprot.writeFieldEnd()
8726 
    oprot.writeFieldStop()
8727 
    oprot.writeStructEnd()
8728 
 
3431 rajveer 8729 
  def validate(self):
8730 
    return
8731 
 
8732 
 
1382 varun.gupt 8733 
  def __repr__(self):
8734 
    L = ['%s=%r' % (key, value)
8735 
      for key, value in self.__dict__.iteritems()]
8736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8737 
 
8738 
  def __eq__(self, other):
8739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8740 
 
8741 
  def __ne__(self, other):
8742 
    return not (self == other)
8743 
 
483 rajveer 8744 
class changeOrderStatus_args:
94 ashish 8745 
  """
8746 
  Attributes:
483 rajveer 8747 
   - orderId
8748 
   - status
8749 
   - description
94 ashish 8750 
  """
8751 
 
8752 
  thrift_spec = (
8753 
    None, # 0
483 rajveer 8754 
    (1, TType.I64, 'orderId', None, None, ), # 1
8755 
    (2, TType.I32, 'status', None, None, ), # 2
8756 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8757 
  )
8758 
 
483 rajveer 8759 
  def __init__(self, orderId=None, status=None, description=None,):
8760 
    self.orderId = orderId
8761 
    self.status = status
8762 
    self.description = description
94 ashish 8763 
 
8764 
  def read(self, iprot):
8765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8767 
      return
8768 
    iprot.readStructBegin()
8769 
    while True:
8770 
      (fname, ftype, fid) = iprot.readFieldBegin()
8771 
      if ftype == TType.STOP:
8772 
        break
8773 
      if fid == 1:
8774 
        if ftype == TType.I64:
483 rajveer 8775 
          self.orderId = iprot.readI64();
94 ashish 8776 
        else:
8777 
          iprot.skip(ftype)
8778 
      elif fid == 2:
483 rajveer 8779 
        if ftype == TType.I32:
8780 
          self.status = iprot.readI32();
94 ashish 8781 
        else:
8782 
          iprot.skip(ftype)
483 rajveer 8783 
      elif fid == 3:
8784 
        if ftype == TType.STRING:
8785 
          self.description = iprot.readString();
8786 
        else:
8787 
          iprot.skip(ftype)
94 ashish 8788 
      else:
8789 
        iprot.skip(ftype)
8790 
      iprot.readFieldEnd()
8791 
    iprot.readStructEnd()
8792 
 
8793 
  def write(self, oprot):
8794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8796 
      return
483 rajveer 8797 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 8798 
    if self.orderId is not None:
483 rajveer 8799 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8800 
      oprot.writeI64(self.orderId)
94 ashish 8801 
      oprot.writeFieldEnd()
3431 rajveer 8802 
    if self.status is not None:
483 rajveer 8803 
      oprot.writeFieldBegin('status', TType.I32, 2)
8804 
      oprot.writeI32(self.status)
94 ashish 8805 
      oprot.writeFieldEnd()
3431 rajveer 8806 
    if self.description is not None:
483 rajveer 8807 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8808 
      oprot.writeString(self.description)
8809 
      oprot.writeFieldEnd()
94 ashish 8810 
    oprot.writeFieldStop()
8811 
    oprot.writeStructEnd()
8812 
 
3431 rajveer 8813 
  def validate(self):
8814 
    return
8815 
 
8816 
 
94 ashish 8817 
  def __repr__(self):
8818 
    L = ['%s=%r' % (key, value)
8819 
      for key, value in self.__dict__.iteritems()]
8820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8821 
 
8822 
  def __eq__(self, other):
8823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8824 
 
8825 
  def __ne__(self, other):
8826 
    return not (self == other)
8827 
 
483 rajveer 8828 
class changeOrderStatus_result:
94 ashish 8829 
  """
8830 
  Attributes:
8831 
   - success
8832 
   - ex
8833 
  """
8834 
 
8835 
  thrift_spec = (
8836 
    (0, TType.BOOL, 'success', None, None, ), # 0
8837 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8838 
  )
8839 
 
8840 
  def __init__(self, success=None, ex=None,):
8841 
    self.success = success
8842 
    self.ex = ex
8843 
 
8844 
  def read(self, iprot):
8845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8847 
      return
8848 
    iprot.readStructBegin()
8849 
    while True:
8850 
      (fname, ftype, fid) = iprot.readFieldBegin()
8851 
      if ftype == TType.STOP:
8852 
        break
8853 
      if fid == 0:
8854 
        if ftype == TType.BOOL:
8855 
          self.success = iprot.readBool();
8856 
        else:
8857 
          iprot.skip(ftype)
8858 
      elif fid == 1:
8859 
        if ftype == TType.STRUCT:
8860 
          self.ex = TransactionServiceException()
8861 
          self.ex.read(iprot)
8862 
        else:
8863 
          iprot.skip(ftype)
8864 
      else:
8865 
        iprot.skip(ftype)
8866 
      iprot.readFieldEnd()
8867 
    iprot.readStructEnd()
8868 
 
8869 
  def write(self, oprot):
8870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8872 
      return
483 rajveer 8873 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 8874 
    if self.success is not None:
94 ashish 8875 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8876 
      oprot.writeBool(self.success)
8877 
      oprot.writeFieldEnd()
3431 rajveer 8878 
    if self.ex is not None:
94 ashish 8879 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8880 
      self.ex.write(oprot)
8881 
      oprot.writeFieldEnd()
8882 
    oprot.writeFieldStop()
8883 
    oprot.writeStructEnd()
8884 
 
3431 rajveer 8885 
  def validate(self):
8886 
    return
8887 
 
8888 
 
94 ashish 8889 
  def __repr__(self):
8890 
    L = ['%s=%r' % (key, value)
8891 
      for key, value in self.__dict__.iteritems()]
8892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8893 
 
8894 
  def __eq__(self, other):
8895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8896 
 
8897 
  def __ne__(self, other):
8898 
    return not (self == other)
8899 
 
3064 chandransh 8900 
class getOrdersForTransaction_args:
494 rajveer 8901 
  """
8902 
  Attributes:
3064 chandransh 8903 
   - transactionId
8904 
   - customerId
494 rajveer 8905 
  """
8906 
 
8907 
  thrift_spec = (
8908 
    None, # 0
3064 chandransh 8909 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8910 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 8911 
  )
8912 
 
3064 chandransh 8913 
  def __init__(self, transactionId=None, customerId=None,):
8914 
    self.transactionId = transactionId
8915 
    self.customerId = customerId
494 rajveer 8916 
 
8917 
  def read(self, iprot):
8918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8920 
      return
8921 
    iprot.readStructBegin()
8922 
    while True:
8923 
      (fname, ftype, fid) = iprot.readFieldBegin()
8924 
      if ftype == TType.STOP:
8925 
        break
8926 
      if fid == 1:
8927 
        if ftype == TType.I64:
3064 chandransh 8928 
          self.transactionId = iprot.readI64();
494 rajveer 8929 
        else:
8930 
          iprot.skip(ftype)
8931 
      elif fid == 2:
3064 chandransh 8932 
        if ftype == TType.I64:
8933 
          self.customerId = iprot.readI64();
494 rajveer 8934 
        else:
8935 
          iprot.skip(ftype)
8936 
      else:
8937 
        iprot.skip(ftype)
8938 
      iprot.readFieldEnd()
8939 
    iprot.readStructEnd()
8940 
 
8941 
  def write(self, oprot):
8942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8944 
      return
3064 chandransh 8945 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 8946 
    if self.transactionId is not None:
3064 chandransh 8947 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8948 
      oprot.writeI64(self.transactionId)
494 rajveer 8949 
      oprot.writeFieldEnd()
3431 rajveer 8950 
    if self.customerId is not None:
3064 chandransh 8951 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
8952 
      oprot.writeI64(self.customerId)
494 rajveer 8953 
      oprot.writeFieldEnd()
8954 
    oprot.writeFieldStop()
8955 
    oprot.writeStructEnd()
8956 
 
3431 rajveer 8957 
  def validate(self):
8958 
    return
8959 
 
8960 
 
494 rajveer 8961 
  def __repr__(self):
8962 
    L = ['%s=%r' % (key, value)
8963 
      for key, value in self.__dict__.iteritems()]
8964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8965 
 
8966 
  def __eq__(self, other):
8967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8968 
 
8969 
  def __ne__(self, other):
8970 
    return not (self == other)
8971 
 
3064 chandransh 8972 
class getOrdersForTransaction_result:
494 rajveer 8973 
  """
8974 
  Attributes:
8975 
   - success
8976 
   - ex
8977 
  """
8978 
 
8979 
  thrift_spec = (
3064 chandransh 8980 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 8981 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8982 
  )
8983 
 
8984 
  def __init__(self, success=None, ex=None,):
8985 
    self.success = success
8986 
    self.ex = ex
8987 
 
8988 
  def read(self, iprot):
8989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8991 
      return
8992 
    iprot.readStructBegin()
8993 
    while True:
8994 
      (fname, ftype, fid) = iprot.readFieldBegin()
8995 
      if ftype == TType.STOP:
8996 
        break
8997 
      if fid == 0:
3064 chandransh 8998 
        if ftype == TType.LIST:
8999 
          self.success = []
5031 varun.gupt 9000 
          (_etype143, _size140) = iprot.readListBegin()
9001 
          for _i144 in xrange(_size140):
9002 
            _elem145 = Order()
9003 
            _elem145.read(iprot)
9004 
            self.success.append(_elem145)
3064 chandransh 9005 
          iprot.readListEnd()
494 rajveer 9006 
        else:
9007 
          iprot.skip(ftype)
9008 
      elif fid == 1:
9009 
        if ftype == TType.STRUCT:
9010 
          self.ex = TransactionServiceException()
9011 
          self.ex.read(iprot)
9012 
        else:
9013 
          iprot.skip(ftype)
9014 
      else:
9015 
        iprot.skip(ftype)
9016 
      iprot.readFieldEnd()
9017 
    iprot.readStructEnd()
9018 
 
9019 
  def write(self, oprot):
9020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9022 
      return
3064 chandransh 9023 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 9024 
    if self.success is not None:
3064 chandransh 9025 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9026 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9027 
      for iter146 in self.success:
9028 
        iter146.write(oprot)
3064 chandransh 9029 
      oprot.writeListEnd()
494 rajveer 9030 
      oprot.writeFieldEnd()
3431 rajveer 9031 
    if self.ex is not None:
494 rajveer 9032 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9033 
      self.ex.write(oprot)
9034 
      oprot.writeFieldEnd()
9035 
    oprot.writeFieldStop()
9036 
    oprot.writeStructEnd()
9037 
 
3431 rajveer 9038 
  def validate(self):
9039 
    return
9040 
 
9041 
 
494 rajveer 9042 
  def __repr__(self):
9043 
    L = ['%s=%r' % (key, value)
9044 
      for key, value in self.__dict__.iteritems()]
9045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9046 
 
9047 
  def __eq__(self, other):
9048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9049 
 
9050 
  def __ne__(self, other):
9051 
    return not (self == other)
9052 
 
3064 chandransh 9053 
class getOrdersForCustomer_args:
1149 chandransh 9054 
  """
9055 
  Attributes:
3064 chandransh 9056 
   - customerId
9057 
   - from_date
9058 
   - to_date
9059 
   - statuses
1149 chandransh 9060 
  """
9061 
 
9062 
  thrift_spec = (
9063 
    None, # 0
3064 chandransh 9064 
    (1, TType.I64, 'customerId', None, None, ), # 1
9065 
    (2, TType.I64, 'from_date', None, None, ), # 2
9066 
    (3, TType.I64, 'to_date', None, None, ), # 3
9067 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 9068 
  )
9069 
 
3064 chandransh 9070 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
9071 
    self.customerId = customerId
9072 
    self.from_date = from_date
9073 
    self.to_date = to_date
9074 
    self.statuses = statuses
1149 chandransh 9075 
 
9076 
  def read(self, iprot):
9077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9079 
      return
9080 
    iprot.readStructBegin()
9081 
    while True:
9082 
      (fname, ftype, fid) = iprot.readFieldBegin()
9083 
      if ftype == TType.STOP:
9084 
        break
9085 
      if fid == 1:
9086 
        if ftype == TType.I64:
3064 chandransh 9087 
          self.customerId = iprot.readI64();
1149 chandransh 9088 
        else:
9089 
          iprot.skip(ftype)
9090 
      elif fid == 2:
9091 
        if ftype == TType.I64:
3064 chandransh 9092 
          self.from_date = iprot.readI64();
1149 chandransh 9093 
        else:
9094 
          iprot.skip(ftype)
2783 chandransh 9095 
      elif fid == 3:
9096 
        if ftype == TType.I64:
3064 chandransh 9097 
          self.to_date = iprot.readI64();
2783 chandransh 9098 
        else:
9099 
          iprot.skip(ftype)
9100 
      elif fid == 4:
3064 chandransh 9101 
        if ftype == TType.LIST:
9102 
          self.statuses = []
5031 varun.gupt 9103 
          (_etype150, _size147) = iprot.readListBegin()
9104 
          for _i151 in xrange(_size147):
9105 
            _elem152 = iprot.readI32();
9106 
            self.statuses.append(_elem152)
3064 chandransh 9107 
          iprot.readListEnd()
2783 chandransh 9108 
        else:
9109 
          iprot.skip(ftype)
1149 chandransh 9110 
      else:
9111 
        iprot.skip(ftype)
9112 
      iprot.readFieldEnd()
9113 
    iprot.readStructEnd()
9114 
 
9115 
  def write(self, oprot):
9116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9118 
      return
3064 chandransh 9119 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 9120 
    if self.customerId is not None:
3064 chandransh 9121 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9122 
      oprot.writeI64(self.customerId)
1149 chandransh 9123 
      oprot.writeFieldEnd()
3431 rajveer 9124 
    if self.from_date is not None:
3064 chandransh 9125 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9126 
      oprot.writeI64(self.from_date)
1149 chandransh 9127 
      oprot.writeFieldEnd()
3431 rajveer 9128 
    if self.to_date is not None:
3064 chandransh 9129 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9130 
      oprot.writeI64(self.to_date)
2783 chandransh 9131 
      oprot.writeFieldEnd()
3431 rajveer 9132 
    if self.statuses is not None:
3064 chandransh 9133 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
9134 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 9135 
      for iter153 in self.statuses:
9136 
        oprot.writeI32(iter153)
3064 chandransh 9137 
      oprot.writeListEnd()
2783 chandransh 9138 
      oprot.writeFieldEnd()
1149 chandransh 9139 
    oprot.writeFieldStop()
9140 
    oprot.writeStructEnd()
9141 
 
3431 rajveer 9142 
  def validate(self):
9143 
    return
9144 
 
9145 
 
1149 chandransh 9146 
  def __repr__(self):
9147 
    L = ['%s=%r' % (key, value)
9148 
      for key, value in self.__dict__.iteritems()]
9149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9150 
 
9151 
  def __eq__(self, other):
9152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9153 
 
9154 
  def __ne__(self, other):
9155 
    return not (self == other)
9156 
 
3064 chandransh 9157 
class getOrdersForCustomer_result:
1149 chandransh 9158 
  """
9159 
  Attributes:
9160 
   - success
9161 
   - ex
9162 
  """
9163 
 
9164 
  thrift_spec = (
3064 chandransh 9165 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 9166 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9167 
  )
9168 
 
9169 
  def __init__(self, success=None, ex=None,):
9170 
    self.success = success
9171 
    self.ex = ex
9172 
 
9173 
  def read(self, iprot):
9174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9176 
      return
9177 
    iprot.readStructBegin()
9178 
    while True:
9179 
      (fname, ftype, fid) = iprot.readFieldBegin()
9180 
      if ftype == TType.STOP:
9181 
        break
9182 
      if fid == 0:
3064 chandransh 9183 
        if ftype == TType.LIST:
9184 
          self.success = []
5031 varun.gupt 9185 
          (_etype157, _size154) = iprot.readListBegin()
9186 
          for _i158 in xrange(_size154):
9187 
            _elem159 = Order()
9188 
            _elem159.read(iprot)
9189 
            self.success.append(_elem159)
3064 chandransh 9190 
          iprot.readListEnd()
1149 chandransh 9191 
        else:
9192 
          iprot.skip(ftype)
9193 
      elif fid == 1:
9194 
        if ftype == TType.STRUCT:
9195 
          self.ex = TransactionServiceException()
9196 
          self.ex.read(iprot)
9197 
        else:
9198 
          iprot.skip(ftype)
9199 
      else:
9200 
        iprot.skip(ftype)
9201 
      iprot.readFieldEnd()
9202 
    iprot.readStructEnd()
9203 
 
9204 
  def write(self, oprot):
9205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9207 
      return
3064 chandransh 9208 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 9209 
    if self.success is not None:
3064 chandransh 9210 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9211 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9212 
      for iter160 in self.success:
9213 
        iter160.write(oprot)
3064 chandransh 9214 
      oprot.writeListEnd()
1149 chandransh 9215 
      oprot.writeFieldEnd()
3431 rajveer 9216 
    if self.ex is not None:
1149 chandransh 9217 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9218 
      self.ex.write(oprot)
9219 
      oprot.writeFieldEnd()
9220 
    oprot.writeFieldStop()
9221 
    oprot.writeStructEnd()
9222 
 
3431 rajveer 9223 
  def validate(self):
9224 
    return
9225 
 
9226 
 
1149 chandransh 9227 
  def __repr__(self):
9228 
    L = ['%s=%r' % (key, value)
9229 
      for key, value in self.__dict__.iteritems()]
9230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9231 
 
9232 
  def __eq__(self, other):
9233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9234 
 
9235 
  def __ne__(self, other):
9236 
    return not (self == other)
9237 
 
3064 chandransh 9238 
class createOrder_args:
921 rajveer 9239 
  """
9240 
  Attributes:
3064 chandransh 9241 
   - order
921 rajveer 9242 
  """
9243 
 
9244 
  thrift_spec = (
9245 
    None, # 0
3064 chandransh 9246 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 9247 
  )
9248 
 
3064 chandransh 9249 
  def __init__(self, order=None,):
9250 
    self.order = order
921 rajveer 9251 
 
9252 
  def read(self, iprot):
9253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9255 
      return
9256 
    iprot.readStructBegin()
9257 
    while True:
9258 
      (fname, ftype, fid) = iprot.readFieldBegin()
9259 
      if ftype == TType.STOP:
9260 
        break
9261 
      if fid == 1:
3064 chandransh 9262 
        if ftype == TType.STRUCT:
9263 
          self.order = Order()
9264 
          self.order.read(iprot)
921 rajveer 9265 
        else:
9266 
          iprot.skip(ftype)
9267 
      else:
9268 
        iprot.skip(ftype)
9269 
      iprot.readFieldEnd()
9270 
    iprot.readStructEnd()
9271 
 
9272 
  def write(self, oprot):
9273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9275 
      return
3064 chandransh 9276 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 9277 
    if self.order is not None:
3064 chandransh 9278 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
9279 
      self.order.write(oprot)
921 rajveer 9280 
      oprot.writeFieldEnd()
9281 
    oprot.writeFieldStop()
9282 
    oprot.writeStructEnd()
9283 
 
3431 rajveer 9284 
  def validate(self):
9285 
    return
9286 
 
9287 
 
921 rajveer 9288 
  def __repr__(self):
9289 
    L = ['%s=%r' % (key, value)
9290 
      for key, value in self.__dict__.iteritems()]
9291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9292 
 
9293 
  def __eq__(self, other):
9294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9295 
 
9296 
  def __ne__(self, other):
9297 
    return not (self == other)
9298 
 
3064 chandransh 9299 
class createOrder_result:
921 rajveer 9300 
  """
9301 
  Attributes:
9302 
   - success
9303 
   - ex
9304 
  """
9305 
 
9306 
  thrift_spec = (
3064 chandransh 9307 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 9308 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9309 
  )
9310 
 
9311 
  def __init__(self, success=None, ex=None,):
9312 
    self.success = success
9313 
    self.ex = ex
9314 
 
9315 
  def read(self, iprot):
9316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9318 
      return
9319 
    iprot.readStructBegin()
9320 
    while True:
9321 
      (fname, ftype, fid) = iprot.readFieldBegin()
9322 
      if ftype == TType.STOP:
9323 
        break
9324 
      if fid == 0:
3064 chandransh 9325 
        if ftype == TType.I64:
9326 
          self.success = iprot.readI64();
921 rajveer 9327 
        else:
9328 
          iprot.skip(ftype)
9329 
      elif fid == 1:
9330 
        if ftype == TType.STRUCT:
9331 
          self.ex = TransactionServiceException()
9332 
          self.ex.read(iprot)
9333 
        else:
9334 
          iprot.skip(ftype)
9335 
      else:
9336 
        iprot.skip(ftype)
9337 
      iprot.readFieldEnd()
9338 
    iprot.readStructEnd()
9339 
 
9340 
  def write(self, oprot):
9341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9343 
      return
3064 chandransh 9344 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 9345 
    if self.success is not None:
3064 chandransh 9346 
      oprot.writeFieldBegin('success', TType.I64, 0)
9347 
      oprot.writeI64(self.success)
921 rajveer 9348 
      oprot.writeFieldEnd()
3431 rajveer 9349 
    if self.ex is not None:
921 rajveer 9350 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9351 
      self.ex.write(oprot)
9352 
      oprot.writeFieldEnd()
9353 
    oprot.writeFieldStop()
9354 
    oprot.writeStructEnd()
9355 
 
3431 rajveer 9356 
  def validate(self):
9357 
    return
9358 
 
9359 
 
921 rajveer 9360 
  def __repr__(self):
9361 
    L = ['%s=%r' % (key, value)
9362 
      for key, value in self.__dict__.iteritems()]
9363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9364 
 
9365 
  def __eq__(self, other):
9366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9367 
 
9368 
  def __ne__(self, other):
9369 
    return not (self == other)
9370 
 
3064 chandransh 9371 
class getOrder_args:
921 rajveer 9372 
  """
9373 
  Attributes:
3064 chandransh 9374 
   - id
921 rajveer 9375 
  """
9376 
 
9377 
  thrift_spec = (
9378 
    None, # 0
3064 chandransh 9379 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 9380 
  )
9381 
 
3064 chandransh 9382 
  def __init__(self, id=None,):
9383 
    self.id = id
921 rajveer 9384 
 
9385 
  def read(self, iprot):
9386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9388 
      return
9389 
    iprot.readStructBegin()
9390 
    while True:
9391 
      (fname, ftype, fid) = iprot.readFieldBegin()
9392 
      if ftype == TType.STOP:
9393 
        break
9394 
      if fid == 1:
9395 
        if ftype == TType.I64:
3064 chandransh 9396 
          self.id = iprot.readI64();
921 rajveer 9397 
        else:
9398 
          iprot.skip(ftype)
9399 
      else:
9400 
        iprot.skip(ftype)
9401 
      iprot.readFieldEnd()
9402 
    iprot.readStructEnd()
9403 
 
9404 
  def write(self, oprot):
9405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9407 
      return
3064 chandransh 9408 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 9409 
    if self.id is not None:
3064 chandransh 9410 
      oprot.writeFieldBegin('id', TType.I64, 1)
9411 
      oprot.writeI64(self.id)
921 rajveer 9412 
      oprot.writeFieldEnd()
9413 
    oprot.writeFieldStop()
9414 
    oprot.writeStructEnd()
9415 
 
3431 rajveer 9416 
  def validate(self):
9417 
    return
9418 
 
9419 
 
921 rajveer 9420 
  def __repr__(self):
9421 
    L = ['%s=%r' % (key, value)
9422 
      for key, value in self.__dict__.iteritems()]
9423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9424 
 
9425 
  def __eq__(self, other):
9426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9427 
 
9428 
  def __ne__(self, other):
9429 
    return not (self == other)
9430 
 
3064 chandransh 9431 
class getOrder_result:
921 rajveer 9432 
  """
9433 
  Attributes:
9434 
   - success
9435 
   - ex
9436 
  """
9437 
 
9438 
  thrift_spec = (
3064 chandransh 9439 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 9440 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9441 
  )
9442 
 
9443 
  def __init__(self, success=None, ex=None,):
9444 
    self.success = success
9445 
    self.ex = ex
9446 
 
9447 
  def read(self, iprot):
9448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9450 
      return
9451 
    iprot.readStructBegin()
9452 
    while True:
9453 
      (fname, ftype, fid) = iprot.readFieldBegin()
9454 
      if ftype == TType.STOP:
9455 
        break
9456 
      if fid == 0:
3064 chandransh 9457 
        if ftype == TType.STRUCT:
9458 
          self.success = Order()
9459 
          self.success.read(iprot)
921 rajveer 9460 
        else:
9461 
          iprot.skip(ftype)
9462 
      elif fid == 1:
9463 
        if ftype == TType.STRUCT:
9464 
          self.ex = TransactionServiceException()
9465 
          self.ex.read(iprot)
9466 
        else:
9467 
          iprot.skip(ftype)
9468 
      else:
9469 
        iprot.skip(ftype)
9470 
      iprot.readFieldEnd()
9471 
    iprot.readStructEnd()
9472 
 
9473 
  def write(self, oprot):
9474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9476 
      return
3064 chandransh 9477 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 9478 
    if self.success is not None:
3064 chandransh 9479 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9480 
      self.success.write(oprot)
921 rajveer 9481 
      oprot.writeFieldEnd()
3431 rajveer 9482 
    if self.ex is not None:
921 rajveer 9483 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9484 
      self.ex.write(oprot)
9485 
      oprot.writeFieldEnd()
9486 
    oprot.writeFieldStop()
9487 
    oprot.writeStructEnd()
9488 
 
3431 rajveer 9489 
  def validate(self):
9490 
    return
9491 
 
9492 
 
921 rajveer 9493 
  def __repr__(self):
9494 
    L = ['%s=%r' % (key, value)
9495 
      for key, value in self.__dict__.iteritems()]
9496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9497 
 
9498 
  def __eq__(self, other):
9499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9500 
 
9501 
  def __ne__(self, other):
9502 
    return not (self == other)
9503 
 
3064 chandransh 9504 
class getLineItemsForOrder_args:
94 ashish 9505 
  """
9506 
  Attributes:
3064 chandransh 9507 
   - orderId
94 ashish 9508 
  """
9509 
 
9510 
  thrift_spec = (
9511 
    None, # 0
3064 chandransh 9512 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 9513 
  )
9514 
 
3064 chandransh 9515 
  def __init__(self, orderId=None,):
9516 
    self.orderId = orderId
94 ashish 9517 
 
9518 
  def read(self, iprot):
9519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9521 
      return
9522 
    iprot.readStructBegin()
9523 
    while True:
9524 
      (fname, ftype, fid) = iprot.readFieldBegin()
9525 
      if ftype == TType.STOP:
9526 
        break
9527 
      if fid == 1:
9528 
        if ftype == TType.I64:
3064 chandransh 9529 
          self.orderId = iprot.readI64();
94 ashish 9530 
        else:
9531 
          iprot.skip(ftype)
9532 
      else:
9533 
        iprot.skip(ftype)
9534 
      iprot.readFieldEnd()
9535 
    iprot.readStructEnd()
9536 
 
9537 
  def write(self, oprot):
9538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9540 
      return
3064 chandransh 9541 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 9542 
    if self.orderId is not None:
3064 chandransh 9543 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9544 
      oprot.writeI64(self.orderId)
94 ashish 9545 
      oprot.writeFieldEnd()
9546 
    oprot.writeFieldStop()
9547 
    oprot.writeStructEnd()
9548 
 
3431 rajveer 9549 
  def validate(self):
9550 
    return
9551 
 
9552 
 
94 ashish 9553 
  def __repr__(self):
9554 
    L = ['%s=%r' % (key, value)
9555 
      for key, value in self.__dict__.iteritems()]
9556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9557 
 
9558 
  def __eq__(self, other):
9559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9560 
 
9561 
  def __ne__(self, other):
9562 
    return not (self == other)
9563 
 
3064 chandransh 9564 
class getLineItemsForOrder_result:
94 ashish 9565 
  """
9566 
  Attributes:
9567 
   - success
9568 
   - ex
9569 
  """
9570 
 
9571 
  thrift_spec = (
3064 chandransh 9572 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 9573 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9574 
  )
9575 
 
9576 
  def __init__(self, success=None, ex=None,):
9577 
    self.success = success
9578 
    self.ex = ex
9579 
 
9580 
  def read(self, iprot):
9581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9583 
      return
9584 
    iprot.readStructBegin()
9585 
    while True:
9586 
      (fname, ftype, fid) = iprot.readFieldBegin()
9587 
      if ftype == TType.STOP:
9588 
        break
9589 
      if fid == 0:
483 rajveer 9590 
        if ftype == TType.LIST:
9591 
          self.success = []
5031 varun.gupt 9592 
          (_etype164, _size161) = iprot.readListBegin()
9593 
          for _i165 in xrange(_size161):
9594 
            _elem166 = LineItem()
9595 
            _elem166.read(iprot)
9596 
            self.success.append(_elem166)
483 rajveer 9597 
          iprot.readListEnd()
94 ashish 9598 
        else:
9599 
          iprot.skip(ftype)
9600 
      elif fid == 1:
9601 
        if ftype == TType.STRUCT:
9602 
          self.ex = TransactionServiceException()
9603 
          self.ex.read(iprot)
9604 
        else:
9605 
          iprot.skip(ftype)
9606 
      else:
9607 
        iprot.skip(ftype)
9608 
      iprot.readFieldEnd()
9609 
    iprot.readStructEnd()
9610 
 
9611 
  def write(self, oprot):
9612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9614 
      return
3064 chandransh 9615 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 9616 
    if self.success is not None:
483 rajveer 9617 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9618 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9619 
      for iter167 in self.success:
9620 
        iter167.write(oprot)
483 rajveer 9621 
      oprot.writeListEnd()
94 ashish 9622 
      oprot.writeFieldEnd()
3431 rajveer 9623 
    if self.ex is not None:
94 ashish 9624 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9625 
      self.ex.write(oprot)
9626 
      oprot.writeFieldEnd()
9627 
    oprot.writeFieldStop()
9628 
    oprot.writeStructEnd()
9629 
 
3431 rajveer 9630 
  def validate(self):
9631 
    return
9632 
 
9633 
 
94 ashish 9634 
  def __repr__(self):
9635 
    L = ['%s=%r' % (key, value)
9636 
      for key, value in self.__dict__.iteritems()]
9637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9638 
 
9639 
  def __eq__(self, other):
9640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9641 
 
9642 
  def __ne__(self, other):
9643 
    return not (self == other)
9644 
 
4999 phani.kuma 9645 
class getOrderList_args:
9646 
  """
9647 
  Attributes:
9648 
   - order_ids
9649 
  """
9650 
 
9651 
  thrift_spec = (
9652 
    None, # 0
9653 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
9654 
  )
9655 
 
9656 
  def __init__(self, order_ids=None,):
9657 
    self.order_ids = order_ids
9658 
 
9659 
  def read(self, iprot):
9660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9662 
      return
9663 
    iprot.readStructBegin()
9664 
    while True:
9665 
      (fname, ftype, fid) = iprot.readFieldBegin()
9666 
      if ftype == TType.STOP:
9667 
        break
9668 
      if fid == 1:
9669 
        if ftype == TType.LIST:
9670 
          self.order_ids = []
5031 varun.gupt 9671 
          (_etype171, _size168) = iprot.readListBegin()
9672 
          for _i172 in xrange(_size168):
9673 
            _elem173 = iprot.readI64();
9674 
            self.order_ids.append(_elem173)
4999 phani.kuma 9675 
          iprot.readListEnd()
9676 
        else:
9677 
          iprot.skip(ftype)
9678 
      else:
9679 
        iprot.skip(ftype)
9680 
      iprot.readFieldEnd()
9681 
    iprot.readStructEnd()
9682 
 
9683 
  def write(self, oprot):
9684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9686 
      return
9687 
    oprot.writeStructBegin('getOrderList_args')
9688 
    if self.order_ids is not None:
9689 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
9690 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
5031 varun.gupt 9691 
      for iter174 in self.order_ids:
9692 
        oprot.writeI64(iter174)
4999 phani.kuma 9693 
      oprot.writeListEnd()
9694 
      oprot.writeFieldEnd()
9695 
    oprot.writeFieldStop()
9696 
    oprot.writeStructEnd()
9697 
 
9698 
  def validate(self):
9699 
    return
9700 
 
9701 
 
9702 
  def __repr__(self):
9703 
    L = ['%s=%r' % (key, value)
9704 
      for key, value in self.__dict__.iteritems()]
9705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9706 
 
9707 
  def __eq__(self, other):
9708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9709 
 
9710 
  def __ne__(self, other):
9711 
    return not (self == other)
9712 
 
9713 
class getOrderList_result:
9714 
  """
9715 
  Attributes:
9716 
   - success
9717 
  """
9718 
 
9719 
  thrift_spec = (
9720 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9721 
  )
9722 
 
9723 
  def __init__(self, success=None,):
9724 
    self.success = success
9725 
 
9726 
  def read(self, iprot):
9727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9729 
      return
9730 
    iprot.readStructBegin()
9731 
    while True:
9732 
      (fname, ftype, fid) = iprot.readFieldBegin()
9733 
      if ftype == TType.STOP:
9734 
        break
9735 
      if fid == 0:
9736 
        if ftype == TType.LIST:
9737 
          self.success = []
5031 varun.gupt 9738 
          (_etype178, _size175) = iprot.readListBegin()
9739 
          for _i179 in xrange(_size175):
9740 
            _elem180 = Order()
9741 
            _elem180.read(iprot)
9742 
            self.success.append(_elem180)
4999 phani.kuma 9743 
          iprot.readListEnd()
9744 
        else:
9745 
          iprot.skip(ftype)
9746 
      else:
9747 
        iprot.skip(ftype)
9748 
      iprot.readFieldEnd()
9749 
    iprot.readStructEnd()
9750 
 
9751 
  def write(self, oprot):
9752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9754 
      return
9755 
    oprot.writeStructBegin('getOrderList_result')
9756 
    if self.success is not None:
9757 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9758 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9759 
      for iter181 in self.success:
9760 
        iter181.write(oprot)
4999 phani.kuma 9761 
      oprot.writeListEnd()
9762 
      oprot.writeFieldEnd()
9763 
    oprot.writeFieldStop()
9764 
    oprot.writeStructEnd()
9765 
 
9766 
  def validate(self):
9767 
    return
9768 
 
9769 
 
9770 
  def __repr__(self):
9771 
    L = ['%s=%r' % (key, value)
9772 
      for key, value in self.__dict__.iteritems()]
9773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9774 
 
9775 
  def __eq__(self, other):
9776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9777 
 
9778 
  def __ne__(self, other):
9779 
    return not (self == other)
9780 
 
3064 chandransh 9781 
class getOrderForCustomer_args:
94 ashish 9782 
  """
9783 
  Attributes:
3064 chandransh 9784 
   - orderId
483 rajveer 9785 
   - customerId
94 ashish 9786 
  """
9787 
 
9788 
  thrift_spec = (
9789 
    None, # 0
3064 chandransh 9790 
    (1, TType.I64, 'orderId', None, None, ), # 1
9791 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 9792 
  )
9793 
 
3064 chandransh 9794 
  def __init__(self, orderId=None, customerId=None,):
9795 
    self.orderId = orderId
483 rajveer 9796 
    self.customerId = customerId
94 ashish 9797 
 
9798 
  def read(self, iprot):
9799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9801 
      return
9802 
    iprot.readStructBegin()
9803 
    while True:
9804 
      (fname, ftype, fid) = iprot.readFieldBegin()
9805 
      if ftype == TType.STOP:
9806 
        break
9807 
      if fid == 1:
9808 
        if ftype == TType.I64:
3064 chandransh 9809 
          self.orderId = iprot.readI64();
94 ashish 9810 
        else:
9811 
          iprot.skip(ftype)
9812 
      elif fid == 2:
9813 
        if ftype == TType.I64:
3064 chandransh 9814 
          self.customerId = iprot.readI64();
94 ashish 9815 
        else:
9816 
          iprot.skip(ftype)
9817 
      else:
9818 
        iprot.skip(ftype)
9819 
      iprot.readFieldEnd()
9820 
    iprot.readStructEnd()
9821 
 
9822 
  def write(self, oprot):
9823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9825 
      return
3064 chandransh 9826 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 9827 
    if self.orderId is not None:
3064 chandransh 9828 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9829 
      oprot.writeI64(self.orderId)
9830 
      oprot.writeFieldEnd()
3431 rajveer 9831 
    if self.customerId is not None:
3064 chandransh 9832 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 9833 
      oprot.writeI64(self.customerId)
94 ashish 9834 
      oprot.writeFieldEnd()
9835 
    oprot.writeFieldStop()
9836 
    oprot.writeStructEnd()
9837 
 
3431 rajveer 9838 
  def validate(self):
9839 
    return
9840 
 
9841 
 
94 ashish 9842 
  def __repr__(self):
9843 
    L = ['%s=%r' % (key, value)
9844 
      for key, value in self.__dict__.iteritems()]
9845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9846 
 
9847 
  def __eq__(self, other):
9848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9849 
 
9850 
  def __ne__(self, other):
9851 
    return not (self == other)
9852 
 
3064 chandransh 9853 
class getOrderForCustomer_result:
94 ashish 9854 
  """
9855 
  Attributes:
9856 
   - success
9857 
   - ex
9858 
  """
9859 
 
9860 
  thrift_spec = (
3064 chandransh 9861 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 9862 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9863 
  )
9864 
 
9865 
  def __init__(self, success=None, ex=None,):
9866 
    self.success = success
9867 
    self.ex = ex
9868 
 
9869 
  def read(self, iprot):
9870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9872 
      return
9873 
    iprot.readStructBegin()
9874 
    while True:
9875 
      (fname, ftype, fid) = iprot.readFieldBegin()
9876 
      if ftype == TType.STOP:
9877 
        break
9878 
      if fid == 0:
3064 chandransh 9879 
        if ftype == TType.STRUCT:
9880 
          self.success = Order()
9881 
          self.success.read(iprot)
94 ashish 9882 
        else:
9883 
          iprot.skip(ftype)
9884 
      elif fid == 1:
9885 
        if ftype == TType.STRUCT:
9886 
          self.ex = TransactionServiceException()
9887 
          self.ex.read(iprot)
9888 
        else:
9889 
          iprot.skip(ftype)
9890 
      else:
9891 
        iprot.skip(ftype)
9892 
      iprot.readFieldEnd()
9893 
    iprot.readStructEnd()
9894 
 
9895 
  def write(self, oprot):
9896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9898 
      return
3064 chandransh 9899 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 9900 
    if self.success is not None:
3064 chandransh 9901 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9902 
      self.success.write(oprot)
94 ashish 9903 
      oprot.writeFieldEnd()
3431 rajveer 9904 
    if self.ex is not None:
94 ashish 9905 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9906 
      self.ex.write(oprot)
9907 
      oprot.writeFieldEnd()
9908 
    oprot.writeFieldStop()
9909 
    oprot.writeStructEnd()
9910 
 
3431 rajveer 9911 
  def validate(self):
9912 
    return
9913 
 
9914 
 
94 ashish 9915 
  def __repr__(self):
9916 
    L = ['%s=%r' % (key, value)
9917 
      for key, value in self.__dict__.iteritems()]
9918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9919 
 
9920 
  def __eq__(self, other):
9921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9922 
 
9923 
  def __ne__(self, other):
9924 
    return not (self == other)
9925 
 
3064 chandransh 9926 
class getAlerts_args:
94 ashish 9927 
  """
9928 
  Attributes:
4394 rajveer 9929 
   - type
4444 rajveer 9930 
   - warehouseId
4394 rajveer 9931 
   - status
9932 
   - timestamp
94 ashish 9933 
  """
9934 
 
9935 
  thrift_spec = (
9936 
    None, # 0
4394 rajveer 9937 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9938 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9939 
    (3, TType.I64, 'status', None, None, ), # 3
9940 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 9941 
  )
9942 
 
4444 rajveer 9943 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 9944 
    self.type = type
4444 rajveer 9945 
    self.warehouseId = warehouseId
4394 rajveer 9946 
    self.status = status
9947 
    self.timestamp = timestamp
94 ashish 9948 
 
9949 
  def read(self, iprot):
9950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9952 
      return
9953 
    iprot.readStructBegin()
9954 
    while True:
9955 
      (fname, ftype, fid) = iprot.readFieldBegin()
9956 
      if ftype == TType.STOP:
9957 
        break
9958 
      if fid == 1:
3064 chandransh 9959 
        if ftype == TType.I64:
4394 rajveer 9960 
          self.type = iprot.readI64();
94 ashish 9961 
        else:
9962 
          iprot.skip(ftype)
3064 chandransh 9963 
      elif fid == 2:
4394 rajveer 9964 
        if ftype == TType.I64:
4444 rajveer 9965 
          self.warehouseId = iprot.readI64();
3064 chandransh 9966 
        else:
9967 
          iprot.skip(ftype)
4394 rajveer 9968 
      elif fid == 3:
9969 
        if ftype == TType.I64:
4444 rajveer 9970 
          self.status = iprot.readI64();
9971 
        else:
9972 
          iprot.skip(ftype)
9973 
      elif fid == 4:
9974 
        if ftype == TType.I64:
4394 rajveer 9975 
          self.timestamp = iprot.readI64();
9976 
        else:
9977 
          iprot.skip(ftype)
94 ashish 9978 
      else:
9979 
        iprot.skip(ftype)
9980 
      iprot.readFieldEnd()
9981 
    iprot.readStructEnd()
9982 
 
9983 
  def write(self, oprot):
9984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9986 
      return
3064 chandransh 9987 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 9988 
    if self.type is not None:
9989 
      oprot.writeFieldBegin('type', TType.I64, 1)
9990 
      oprot.writeI64(self.type)
94 ashish 9991 
      oprot.writeFieldEnd()
4444 rajveer 9992 
    if self.warehouseId is not None:
9993 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9994 
      oprot.writeI64(self.warehouseId)
9995 
      oprot.writeFieldEnd()
4394 rajveer 9996 
    if self.status is not None:
4444 rajveer 9997 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 9998 
      oprot.writeI64(self.status)
3064 chandransh 9999 
      oprot.writeFieldEnd()
4394 rajveer 10000 
    if self.timestamp is not None:
4444 rajveer 10001 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 10002 
      oprot.writeI64(self.timestamp)
10003 
      oprot.writeFieldEnd()
94 ashish 10004 
    oprot.writeFieldStop()
10005 
    oprot.writeStructEnd()
10006 
 
3431 rajveer 10007 
  def validate(self):
10008 
    return
10009 
 
10010 
 
94 ashish 10011 
  def __repr__(self):
10012 
    L = ['%s=%r' % (key, value)
10013 
      for key, value in self.__dict__.iteritems()]
10014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10015 
 
10016 
  def __eq__(self, other):
10017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10018 
 
10019 
  def __ne__(self, other):
10020 
    return not (self == other)
10021 
 
3064 chandransh 10022 
class getAlerts_result:
94 ashish 10023 
  """
10024 
  Attributes:
10025 
   - success
10026 
  """
10027 
 
10028 
  thrift_spec = (
3064 chandransh 10029 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 10030 
  )
10031 
 
3064 chandransh 10032 
  def __init__(self, success=None,):
94 ashish 10033 
    self.success = success
10034 
 
10035 
  def read(self, iprot):
10036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10038 
      return
10039 
    iprot.readStructBegin()
10040 
    while True:
10041 
      (fname, ftype, fid) = iprot.readFieldBegin()
10042 
      if ftype == TType.STOP:
10043 
        break
10044 
      if fid == 0:
3064 chandransh 10045 
        if ftype == TType.LIST:
10046 
          self.success = []
5031 varun.gupt 10047 
          (_etype185, _size182) = iprot.readListBegin()
10048 
          for _i186 in xrange(_size182):
10049 
            _elem187 = Alert()
10050 
            _elem187.read(iprot)
10051 
            self.success.append(_elem187)
3064 chandransh 10052 
          iprot.readListEnd()
94 ashish 10053 
        else:
10054 
          iprot.skip(ftype)
10055 
      else:
10056 
        iprot.skip(ftype)
10057 
      iprot.readFieldEnd()
10058 
    iprot.readStructEnd()
10059 
 
10060 
  def write(self, oprot):
10061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10063 
      return
3064 chandransh 10064 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 10065 
    if self.success is not None:
3064 chandransh 10066 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10067 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10068 
      for iter188 in self.success:
10069 
        iter188.write(oprot)
3064 chandransh 10070 
      oprot.writeListEnd()
94 ashish 10071 
      oprot.writeFieldEnd()
10072 
    oprot.writeFieldStop()
10073 
    oprot.writeStructEnd()
10074 
 
3431 rajveer 10075 
  def validate(self):
10076 
    return
10077 
 
10078 
 
94 ashish 10079 
  def __repr__(self):
10080 
    L = ['%s=%r' % (key, value)
10081 
      for key, value in self.__dict__.iteritems()]
10082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10083 
 
10084 
  def __eq__(self, other):
10085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10086 
 
10087 
  def __ne__(self, other):
10088 
    return not (self == other)
10089 
 
4394 rajveer 10090 
class addAlert_args:
94 ashish 10091 
  """
10092 
  Attributes:
3064 chandransh 10093 
   - type
4444 rajveer 10094 
   - warehouseId
4394 rajveer 10095 
   - description
94 ashish 10096 
  """
10097 
 
10098 
  thrift_spec = (
10099 
    None, # 0
4394 rajveer 10100 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10101 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10102 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10103 
  )
10104 
 
4444 rajveer 10105 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 10106 
    self.type = type
4444 rajveer 10107 
    self.warehouseId = warehouseId
4394 rajveer 10108 
    self.description = description
94 ashish 10109 
 
10110 
  def read(self, iprot):
10111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10113 
      return
10114 
    iprot.readStructBegin()
10115 
    while True:
10116 
      (fname, ftype, fid) = iprot.readFieldBegin()
10117 
      if ftype == TType.STOP:
10118 
        break
10119 
      if fid == 1:
10120 
        if ftype == TType.I64:
4394 rajveer 10121 
          self.type = iprot.readI64();
94 ashish 10122 
        else:
10123 
          iprot.skip(ftype)
3064 chandransh 10124 
      elif fid == 2:
4444 rajveer 10125 
        if ftype == TType.I64:
10126 
          self.warehouseId = iprot.readI64();
10127 
        else:
10128 
          iprot.skip(ftype)
10129 
      elif fid == 3:
3064 chandransh 10130 
        if ftype == TType.STRING:
4394 rajveer 10131 
          self.description = iprot.readString();
3064 chandransh 10132 
        else:
10133 
          iprot.skip(ftype)
94 ashish 10134 
      else:
10135 
        iprot.skip(ftype)
10136 
      iprot.readFieldEnd()
10137 
    iprot.readStructEnd()
10138 
 
10139 
  def write(self, oprot):
10140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10142 
      return
4394 rajveer 10143 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 10144 
    if self.type is not None:
4394 rajveer 10145 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 10146 
      oprot.writeI64(self.type)
10147 
      oprot.writeFieldEnd()
4444 rajveer 10148 
    if self.warehouseId is not None:
10149 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10150 
      oprot.writeI64(self.warehouseId)
10151 
      oprot.writeFieldEnd()
4394 rajveer 10152 
    if self.description is not None:
4444 rajveer 10153 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 10154 
      oprot.writeString(self.description)
3064 chandransh 10155 
      oprot.writeFieldEnd()
94 ashish 10156 
    oprot.writeFieldStop()
10157 
    oprot.writeStructEnd()
10158 
 
3431 rajveer 10159 
  def validate(self):
10160 
    return
10161 
 
10162 
 
94 ashish 10163 
  def __repr__(self):
10164 
    L = ['%s=%r' % (key, value)
10165 
      for key, value in self.__dict__.iteritems()]
10166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10167 
 
10168 
  def __eq__(self, other):
10169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10170 
 
10171 
  def __ne__(self, other):
10172 
    return not (self == other)
10173 
 
4394 rajveer 10174 
class addAlert_result:
3064 chandransh 10175 
 
10176 
  thrift_spec = (
10177 
  )
10178 
 
10179 
  def read(self, iprot):
10180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10182 
      return
10183 
    iprot.readStructBegin()
10184 
    while True:
10185 
      (fname, ftype, fid) = iprot.readFieldBegin()
10186 
      if ftype == TType.STOP:
10187 
        break
10188 
      else:
10189 
        iprot.skip(ftype)
10190 
      iprot.readFieldEnd()
10191 
    iprot.readStructEnd()
10192 
 
10193 
  def write(self, oprot):
10194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10196 
      return
4394 rajveer 10197 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 10198 
    oprot.writeFieldStop()
10199 
    oprot.writeStructEnd()
10200 
 
3431 rajveer 10201 
  def validate(self):
10202 
    return
10203 
 
10204 
 
3064 chandransh 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 
 
4444 rajveer 10216 
class markAlertsAsSeen_args:
10217 
  """
10218 
  Attributes:
10219 
   - warehouseId
10220 
  """
10221 
 
10222 
  thrift_spec = (
10223 
    None, # 0
10224 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10225 
  )
10226 
 
10227 
  def __init__(self, warehouseId=None,):
10228 
    self.warehouseId = warehouseId
10229 
 
10230 
  def read(self, iprot):
10231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10233 
      return
10234 
    iprot.readStructBegin()
10235 
    while True:
10236 
      (fname, ftype, fid) = iprot.readFieldBegin()
10237 
      if ftype == TType.STOP:
10238 
        break
10239 
      if fid == 1:
10240 
        if ftype == TType.I64:
10241 
          self.warehouseId = iprot.readI64();
10242 
        else:
10243 
          iprot.skip(ftype)
10244 
      else:
10245 
        iprot.skip(ftype)
10246 
      iprot.readFieldEnd()
10247 
    iprot.readStructEnd()
10248 
 
10249 
  def write(self, oprot):
10250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10252 
      return
10253 
    oprot.writeStructBegin('markAlertsAsSeen_args')
10254 
    if self.warehouseId is not None:
10255 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10256 
      oprot.writeI64(self.warehouseId)
10257 
      oprot.writeFieldEnd()
10258 
    oprot.writeFieldStop()
10259 
    oprot.writeStructEnd()
10260 
 
10261 
  def validate(self):
10262 
    return
10263 
 
10264 
 
10265 
  def __repr__(self):
10266 
    L = ['%s=%r' % (key, value)
10267 
      for key, value in self.__dict__.iteritems()]
10268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10269 
 
10270 
  def __eq__(self, other):
10271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10272 
 
10273 
  def __ne__(self, other):
10274 
    return not (self == other)
10275 
 
10276 
class markAlertsAsSeen_result:
10277 
 
10278 
  thrift_spec = (
10279 
  )
10280 
 
10281 
  def read(self, iprot):
10282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10284 
      return
10285 
    iprot.readStructBegin()
10286 
    while True:
10287 
      (fname, ftype, fid) = iprot.readFieldBegin()
10288 
      if ftype == TType.STOP:
10289 
        break
10290 
      else:
10291 
        iprot.skip(ftype)
10292 
      iprot.readFieldEnd()
10293 
    iprot.readStructEnd()
10294 
 
10295 
  def write(self, oprot):
10296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10298 
      return
10299 
    oprot.writeStructBegin('markAlertsAsSeen_result')
10300 
    oprot.writeFieldStop()
10301 
    oprot.writeStructEnd()
10302 
 
10303 
  def validate(self):
10304 
    return
10305 
 
10306 
 
10307 
  def __repr__(self):
10308 
    L = ['%s=%r' % (key, value)
10309 
      for key, value in self.__dict__.iteritems()]
10310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10311 
 
10312 
  def __eq__(self, other):
10313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10314 
 
10315 
  def __ne__(self, other):
10316 
    return not (self == other)
10317 
 
3064 chandransh 10318 
class getValidOrderCount_args:
10319 
 
10320 
  thrift_spec = (
10321 
  )
10322 
 
10323 
  def read(self, iprot):
10324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10326 
      return
10327 
    iprot.readStructBegin()
10328 
    while True:
10329 
      (fname, ftype, fid) = iprot.readFieldBegin()
10330 
      if ftype == TType.STOP:
10331 
        break
10332 
      else:
10333 
        iprot.skip(ftype)
10334 
      iprot.readFieldEnd()
10335 
    iprot.readStructEnd()
10336 
 
10337 
  def write(self, oprot):
10338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10340 
      return
10341 
    oprot.writeStructBegin('getValidOrderCount_args')
10342 
    oprot.writeFieldStop()
10343 
    oprot.writeStructEnd()
10344 
 
3431 rajveer 10345 
  def validate(self):
10346 
    return
10347 
 
10348 
 
3064 chandransh 10349 
  def __repr__(self):
10350 
    L = ['%s=%r' % (key, value)
10351 
      for key, value in self.__dict__.iteritems()]
10352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10353 
 
10354 
  def __eq__(self, other):
10355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10356 
 
10357 
  def __ne__(self, other):
10358 
    return not (self == other)
10359 
 
10360 
class getValidOrderCount_result:
94 ashish 10361 
  """
10362 
  Attributes:
10363 
   - success
10364 
  """
10365 
 
10366 
  thrift_spec = (
3064 chandransh 10367 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10368 
  )
10369 
 
3064 chandransh 10370 
  def __init__(self, success=None,):
94 ashish 10371 
    self.success = success
10372 
 
10373 
  def read(self, iprot):
10374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10376 
      return
10377 
    iprot.readStructBegin()
10378 
    while True:
10379 
      (fname, ftype, fid) = iprot.readFieldBegin()
10380 
      if ftype == TType.STOP:
10381 
        break
10382 
      if fid == 0:
3064 chandransh 10383 
        if ftype == TType.I64:
10384 
          self.success = iprot.readI64();
94 ashish 10385 
        else:
10386 
          iprot.skip(ftype)
10387 
      else:
10388 
        iprot.skip(ftype)
10389 
      iprot.readFieldEnd()
10390 
    iprot.readStructEnd()
10391 
 
10392 
  def write(self, oprot):
10393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10395 
      return
3064 chandransh 10396 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 10397 
    if self.success is not None:
3064 chandransh 10398 
      oprot.writeFieldBegin('success', TType.I64, 0)
10399 
      oprot.writeI64(self.success)
94 ashish 10400 
      oprot.writeFieldEnd()
10401 
    oprot.writeFieldStop()
10402 
    oprot.writeStructEnd()
10403 
 
3431 rajveer 10404 
  def validate(self):
10405 
    return
10406 
 
10407 
 
94 ashish 10408 
  def __repr__(self):
10409 
    L = ['%s=%r' % (key, value)
10410 
      for key, value in self.__dict__.iteritems()]
10411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10412 
 
10413 
  def __eq__(self, other):
10414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10415 
 
10416 
  def __ne__(self, other):
10417 
    return not (self == other)
10418 
 
3064 chandransh 10419 
class getNoOfCustomersWithSuccessfulTransaction_args:
10420 
 
10421 
  thrift_spec = (
10422 
  )
10423 
 
10424 
  def read(self, iprot):
10425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10427 
      return
10428 
    iprot.readStructBegin()
10429 
    while True:
10430 
      (fname, ftype, fid) = iprot.readFieldBegin()
10431 
      if ftype == TType.STOP:
10432 
        break
10433 
      else:
10434 
        iprot.skip(ftype)
10435 
      iprot.readFieldEnd()
10436 
    iprot.readStructEnd()
10437 
 
10438 
  def write(self, oprot):
10439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10441 
      return
10442 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
10443 
    oprot.writeFieldStop()
10444 
    oprot.writeStructEnd()
10445 
 
3431 rajveer 10446 
  def validate(self):
10447 
    return
10448 
 
10449 
 
3064 chandransh 10450 
  def __repr__(self):
10451 
    L = ['%s=%r' % (key, value)
10452 
      for key, value in self.__dict__.iteritems()]
10453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10454 
 
10455 
  def __eq__(self, other):
10456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10457 
 
10458 
  def __ne__(self, other):
10459 
    return not (self == other)
10460 
 
10461 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 10462 
  """
10463 
  Attributes:
3064 chandransh 10464 
   - success
94 ashish 10465 
  """
10466 
 
10467 
  thrift_spec = (
3064 chandransh 10468 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10469 
  )
10470 
 
3064 chandransh 10471 
  def __init__(self, success=None,):
10472 
    self.success = success
94 ashish 10473 
 
10474 
  def read(self, iprot):
10475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10477 
      return
10478 
    iprot.readStructBegin()
10479 
    while True:
10480 
      (fname, ftype, fid) = iprot.readFieldBegin()
10481 
      if ftype == TType.STOP:
10482 
        break
3064 chandransh 10483 
      if fid == 0:
94 ashish 10484 
        if ftype == TType.I64:
3064 chandransh 10485 
          self.success = iprot.readI64();
94 ashish 10486 
        else:
10487 
          iprot.skip(ftype)
10488 
      else:
10489 
        iprot.skip(ftype)
10490 
      iprot.readFieldEnd()
10491 
    iprot.readStructEnd()
10492 
 
10493 
  def write(self, oprot):
10494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10496 
      return
3064 chandransh 10497 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 10498 
    if self.success is not None:
3064 chandransh 10499 
      oprot.writeFieldBegin('success', TType.I64, 0)
10500 
      oprot.writeI64(self.success)
94 ashish 10501 
      oprot.writeFieldEnd()
10502 
    oprot.writeFieldStop()
10503 
    oprot.writeStructEnd()
10504 
 
3431 rajveer 10505 
  def validate(self):
10506 
    return
10507 
 
10508 
 
94 ashish 10509 
  def __repr__(self):
10510 
    L = ['%s=%r' % (key, value)
10511 
      for key, value in self.__dict__.iteritems()]
10512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10513 
 
10514 
  def __eq__(self, other):
10515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10516 
 
10517 
  def __ne__(self, other):
10518 
    return not (self == other)
10519 
 
3064 chandransh 10520 
class getValidOrdersAmountRange_args:
10521 
 
10522 
  thrift_spec = (
10523 
  )
10524 
 
10525 
  def read(self, iprot):
10526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10528 
      return
10529 
    iprot.readStructBegin()
10530 
    while True:
10531 
      (fname, ftype, fid) = iprot.readFieldBegin()
10532 
      if ftype == TType.STOP:
10533 
        break
10534 
      else:
10535 
        iprot.skip(ftype)
10536 
      iprot.readFieldEnd()
10537 
    iprot.readStructEnd()
10538 
 
10539 
  def write(self, oprot):
10540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10542 
      return
10543 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
10544 
    oprot.writeFieldStop()
10545 
    oprot.writeStructEnd()
10546 
 
3431 rajveer 10547 
  def validate(self):
10548 
    return
10549 
 
10550 
 
3064 chandransh 10551 
  def __repr__(self):
10552 
    L = ['%s=%r' % (key, value)
10553 
      for key, value in self.__dict__.iteritems()]
10554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10555 
 
10556 
  def __eq__(self, other):
10557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10558 
 
10559 
  def __ne__(self, other):
10560 
    return not (self == other)
10561 
 
10562 
class getValidOrdersAmountRange_result:
94 ashish 10563 
  """
10564 
  Attributes:
10565 
   - success
10566 
  """
10567 
 
10568 
  thrift_spec = (
3064 chandransh 10569 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 10570 
  )
10571 
 
3064 chandransh 10572 
  def __init__(self, success=None,):
94 ashish 10573 
    self.success = success
10574 
 
10575 
  def read(self, iprot):
10576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10578 
      return
10579 
    iprot.readStructBegin()
10580 
    while True:
10581 
      (fname, ftype, fid) = iprot.readFieldBegin()
10582 
      if ftype == TType.STOP:
10583 
        break
10584 
      if fid == 0:
483 rajveer 10585 
        if ftype == TType.LIST:
10586 
          self.success = []
5031 varun.gupt 10587 
          (_etype192, _size189) = iprot.readListBegin()
10588 
          for _i193 in xrange(_size189):
10589 
            _elem194 = iprot.readDouble();
10590 
            self.success.append(_elem194)
483 rajveer 10591 
          iprot.readListEnd()
94 ashish 10592 
        else:
10593 
          iprot.skip(ftype)
10594 
      else:
10595 
        iprot.skip(ftype)
10596 
      iprot.readFieldEnd()
10597 
    iprot.readStructEnd()
10598 
 
10599 
  def write(self, oprot):
10600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10602 
      return
3064 chandransh 10603 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 10604 
    if self.success is not None:
483 rajveer 10605 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 10606 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
5031 varun.gupt 10607 
      for iter195 in self.success:
10608 
        oprot.writeDouble(iter195)
483 rajveer 10609 
      oprot.writeListEnd()
94 ashish 10610 
      oprot.writeFieldEnd()
10611 
    oprot.writeFieldStop()
10612 
    oprot.writeStructEnd()
10613 
 
3431 rajveer 10614 
  def validate(self):
10615 
    return
10616 
 
10617 
 
94 ashish 10618 
  def __repr__(self):
10619 
    L = ['%s=%r' % (key, value)
10620 
      for key, value in self.__dict__.iteritems()]
10621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10622 
 
10623 
  def __eq__(self, other):
10624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10625 
 
10626 
  def __ne__(self, other):
10627 
    return not (self == other)
10628 
 
3064 chandransh 10629 
class getValidOrders_args:
1528 ankur.sing 10630 
  """
10631 
  Attributes:
3064 chandransh 10632 
   - limit
1528 ankur.sing 10633 
  """
10634 
 
10635 
  thrift_spec = (
10636 
    None, # 0
3064 chandransh 10637 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 10638 
  )
10639 
 
3064 chandransh 10640 
  def __init__(self, limit=None,):
10641 
    self.limit = limit
1528 ankur.sing 10642 
 
10643 
  def read(self, iprot):
10644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10646 
      return
10647 
    iprot.readStructBegin()
10648 
    while True:
10649 
      (fname, ftype, fid) = iprot.readFieldBegin()
10650 
      if ftype == TType.STOP:
10651 
        break
10652 
      if fid == 1:
10653 
        if ftype == TType.I64:
3064 chandransh 10654 
          self.limit = iprot.readI64();
1528 ankur.sing 10655 
        else:
10656 
          iprot.skip(ftype)
10657 
      else:
10658 
        iprot.skip(ftype)
10659 
      iprot.readFieldEnd()
10660 
    iprot.readStructEnd()
10661 
 
10662 
  def write(self, oprot):
10663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10665 
      return
3064 chandransh 10666 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 10667 
    if self.limit is not None:
3064 chandransh 10668 
      oprot.writeFieldBegin('limit', TType.I64, 1)
10669 
      oprot.writeI64(self.limit)
1528 ankur.sing 10670 
      oprot.writeFieldEnd()
10671 
    oprot.writeFieldStop()
10672 
    oprot.writeStructEnd()
10673 
 
3431 rajveer 10674 
  def validate(self):
10675 
    return
10676 
 
10677 
 
1528 ankur.sing 10678 
  def __repr__(self):
10679 
    L = ['%s=%r' % (key, value)
10680 
      for key, value in self.__dict__.iteritems()]
10681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10682 
 
10683 
  def __eq__(self, other):
10684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10685 
 
10686 
  def __ne__(self, other):
10687 
    return not (self == other)
10688 
 
3064 chandransh 10689 
class getValidOrders_result:
1528 ankur.sing 10690 
  """
10691 
  Attributes:
10692 
   - success
10693 
  """
10694 
 
10695 
  thrift_spec = (
3064 chandransh 10696 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 10697 
  )
10698 
 
3064 chandransh 10699 
  def __init__(self, success=None,):
1528 ankur.sing 10700 
    self.success = success
10701 
 
10702 
  def read(self, iprot):
10703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10705 
      return
10706 
    iprot.readStructBegin()
10707 
    while True:
10708 
      (fname, ftype, fid) = iprot.readFieldBegin()
10709 
      if ftype == TType.STOP:
10710 
        break
10711 
      if fid == 0:
3064 chandransh 10712 
        if ftype == TType.LIST:
10713 
          self.success = []
5031 varun.gupt 10714 
          (_etype199, _size196) = iprot.readListBegin()
10715 
          for _i200 in xrange(_size196):
10716 
            _elem201 = Order()
10717 
            _elem201.read(iprot)
10718 
            self.success.append(_elem201)
3064 chandransh 10719 
          iprot.readListEnd()
1528 ankur.sing 10720 
        else:
10721 
          iprot.skip(ftype)
10722 
      else:
10723 
        iprot.skip(ftype)
10724 
      iprot.readFieldEnd()
10725 
    iprot.readStructEnd()
10726 
 
10727 
  def write(self, oprot):
10728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10730 
      return
3064 chandransh 10731 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 10732 
    if self.success is not None:
3064 chandransh 10733 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10734 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10735 
      for iter202 in self.success:
10736 
        iter202.write(oprot)
3064 chandransh 10737 
      oprot.writeListEnd()
1528 ankur.sing 10738 
      oprot.writeFieldEnd()
10739 
    oprot.writeFieldStop()
10740 
    oprot.writeStructEnd()
10741 
 
3431 rajveer 10742 
  def validate(self):
10743 
    return
10744 
 
10745 
 
1528 ankur.sing 10746 
  def __repr__(self):
10747 
    L = ['%s=%r' % (key, value)
10748 
      for key, value in self.__dict__.iteritems()]
10749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10750 
 
10751 
  def __eq__(self, other):
10752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10753 
 
10754 
  def __ne__(self, other):
10755 
    return not (self == other)
10756 
 
1220 chandransh 10757 
class batchOrders_args:
10758 
  """
10759 
  Attributes:
10760 
   - warehouseId
10761 
  """
10762 
 
10763 
  thrift_spec = (
10764 
    None, # 0
10765 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10766 
  )
10767 
 
10768 
  def __init__(self, warehouseId=None,):
10769 
    self.warehouseId = warehouseId
10770 
 
10771 
  def read(self, iprot):
10772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10774 
      return
10775 
    iprot.readStructBegin()
10776 
    while True:
10777 
      (fname, ftype, fid) = iprot.readFieldBegin()
10778 
      if ftype == TType.STOP:
10779 
        break
10780 
      if fid == 1:
10781 
        if ftype == TType.I64:
10782 
          self.warehouseId = iprot.readI64();
10783 
        else:
10784 
          iprot.skip(ftype)
10785 
      else:
10786 
        iprot.skip(ftype)
10787 
      iprot.readFieldEnd()
10788 
    iprot.readStructEnd()
10789 
 
10790 
  def write(self, oprot):
10791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10793 
      return
10794 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 10795 
    if self.warehouseId is not None:
1220 chandransh 10796 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10797 
      oprot.writeI64(self.warehouseId)
10798 
      oprot.writeFieldEnd()
10799 
    oprot.writeFieldStop()
10800 
    oprot.writeStructEnd()
10801 
 
3431 rajveer 10802 
  def validate(self):
10803 
    return
10804 
 
10805 
 
1220 chandransh 10806 
  def __repr__(self):
10807 
    L = ['%s=%r' % (key, value)
10808 
      for key, value in self.__dict__.iteritems()]
10809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10810 
 
10811 
  def __eq__(self, other):
10812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10813 
 
10814 
  def __ne__(self, other):
10815 
    return not (self == other)
10816 
 
10817 
class batchOrders_result:
10818 
  """
10819 
  Attributes:
10820 
   - success
10821 
   - ex
10822 
  """
10823 
 
10824 
  thrift_spec = (
10825 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10826 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10827 
  )
10828 
 
10829 
  def __init__(self, success=None, ex=None,):
10830 
    self.success = success
10831 
    self.ex = ex
10832 
 
10833 
  def read(self, iprot):
10834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10836 
      return
10837 
    iprot.readStructBegin()
10838 
    while True:
10839 
      (fname, ftype, fid) = iprot.readFieldBegin()
10840 
      if ftype == TType.STOP:
10841 
        break
10842 
      if fid == 0:
10843 
        if ftype == TType.LIST:
10844 
          self.success = []
5031 varun.gupt 10845 
          (_etype206, _size203) = iprot.readListBegin()
10846 
          for _i207 in xrange(_size203):
10847 
            _elem208 = Order()
10848 
            _elem208.read(iprot)
10849 
            self.success.append(_elem208)
1220 chandransh 10850 
          iprot.readListEnd()
10851 
        else:
10852 
          iprot.skip(ftype)
10853 
      elif fid == 1:
10854 
        if ftype == TType.STRUCT:
10855 
          self.ex = TransactionServiceException()
10856 
          self.ex.read(iprot)
10857 
        else:
10858 
          iprot.skip(ftype)
10859 
      else:
10860 
        iprot.skip(ftype)
10861 
      iprot.readFieldEnd()
10862 
    iprot.readStructEnd()
10863 
 
10864 
  def write(self, oprot):
10865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10867 
      return
10868 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 10869 
    if self.success is not None:
1220 chandransh 10870 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10871 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10872 
      for iter209 in self.success:
10873 
        iter209.write(oprot)
1220 chandransh 10874 
      oprot.writeListEnd()
10875 
      oprot.writeFieldEnd()
3431 rajveer 10876 
    if self.ex is not None:
1220 chandransh 10877 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10878 
      self.ex.write(oprot)
10879 
      oprot.writeFieldEnd()
10880 
    oprot.writeFieldStop()
10881 
    oprot.writeStructEnd()
10882 
 
3431 rajveer 10883 
  def validate(self):
10884 
    return
10885 
 
10886 
 
1220 chandransh 10887 
  def __repr__(self):
10888 
    L = ['%s=%r' % (key, value)
10889 
      for key, value in self.__dict__.iteritems()]
10890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10891 
 
10892 
  def __eq__(self, other):
10893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10894 
 
10895 
  def __ne__(self, other):
10896 
    return not (self == other)
10897 
 
1208 chandransh 10898 
class markOrderAsOutOfStock_args:
10899 
  """
10900 
  Attributes:
10901 
   - orderId
10902 
  """
10903 
 
10904 
  thrift_spec = (
10905 
    None, # 0
10906 
    (1, TType.I64, 'orderId', None, None, ), # 1
10907 
  )
10908 
 
10909 
  def __init__(self, orderId=None,):
10910 
    self.orderId = orderId
10911 
 
10912 
  def read(self, iprot):
10913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10915 
      return
10916 
    iprot.readStructBegin()
10917 
    while True:
10918 
      (fname, ftype, fid) = iprot.readFieldBegin()
10919 
      if ftype == TType.STOP:
10920 
        break
10921 
      if fid == 1:
10922 
        if ftype == TType.I64:
10923 
          self.orderId = iprot.readI64();
10924 
        else:
10925 
          iprot.skip(ftype)
10926 
      else:
10927 
        iprot.skip(ftype)
10928 
      iprot.readFieldEnd()
10929 
    iprot.readStructEnd()
10930 
 
10931 
  def write(self, oprot):
10932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10934 
      return
10935 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 10936 
    if self.orderId is not None:
1208 chandransh 10937 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10938 
      oprot.writeI64(self.orderId)
10939 
      oprot.writeFieldEnd()
10940 
    oprot.writeFieldStop()
10941 
    oprot.writeStructEnd()
10942 
 
3431 rajveer 10943 
  def validate(self):
10944 
    return
10945 
 
10946 
 
1208 chandransh 10947 
  def __repr__(self):
10948 
    L = ['%s=%r' % (key, value)
10949 
      for key, value in self.__dict__.iteritems()]
10950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10951 
 
10952 
  def __eq__(self, other):
10953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10954 
 
10955 
  def __ne__(self, other):
10956 
    return not (self == other)
10957 
 
10958 
class markOrderAsOutOfStock_result:
10959 
  """
10960 
  Attributes:
10961 
   - success
10962 
   - ex
10963 
  """
10964 
 
10965 
  thrift_spec = (
10966 
    (0, TType.BOOL, 'success', None, None, ), # 0
10967 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10968 
  )
10969 
 
10970 
  def __init__(self, success=None, ex=None,):
10971 
    self.success = success
10972 
    self.ex = ex
10973 
 
10974 
  def read(self, iprot):
10975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10977 
      return
10978 
    iprot.readStructBegin()
10979 
    while True:
10980 
      (fname, ftype, fid) = iprot.readFieldBegin()
10981 
      if ftype == TType.STOP:
10982 
        break
10983 
      if fid == 0:
10984 
        if ftype == TType.BOOL:
10985 
          self.success = iprot.readBool();
10986 
        else:
10987 
          iprot.skip(ftype)
10988 
      elif fid == 1:
10989 
        if ftype == TType.STRUCT:
10990 
          self.ex = TransactionServiceException()
10991 
          self.ex.read(iprot)
10992 
        else:
10993 
          iprot.skip(ftype)
10994 
      else:
10995 
        iprot.skip(ftype)
10996 
      iprot.readFieldEnd()
10997 
    iprot.readStructEnd()
10998 
 
10999 
  def write(self, oprot):
11000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11002 
      return
11003 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 11004 
    if self.success is not None:
1208 chandransh 11005 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11006 
      oprot.writeBool(self.success)
11007 
      oprot.writeFieldEnd()
3431 rajveer 11008 
    if self.ex is not None:
1208 chandransh 11009 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11010 
      self.ex.write(oprot)
11011 
      oprot.writeFieldEnd()
11012 
    oprot.writeFieldStop()
11013 
    oprot.writeStructEnd()
11014 
 
3431 rajveer 11015 
  def validate(self):
11016 
    return
11017 
 
11018 
 
1208 chandransh 11019 
  def __repr__(self):
11020 
    L = ['%s=%r' % (key, value)
11021 
      for key, value in self.__dict__.iteritems()]
11022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11023 
 
11024 
  def __eq__(self, other):
11025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11026 
 
11027 
  def __ne__(self, other):
11028 
    return not (self == other)
11029 
 
3064 chandransh 11030 
class verifyOrder_args:
759 chandransh 11031 
  """
11032 
  Attributes:
3064 chandransh 11033 
   - orderId
759 chandransh 11034 
  """
11035 
 
11036 
  thrift_spec = (
11037 
    None, # 0
3064 chandransh 11038 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 11039 
  )
11040 
 
3064 chandransh 11041 
  def __init__(self, orderId=None,):
11042 
    self.orderId = orderId
759 chandransh 11043 
 
11044 
  def read(self, iprot):
11045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11047 
      return
11048 
    iprot.readStructBegin()
11049 
    while True:
11050 
      (fname, ftype, fid) = iprot.readFieldBegin()
11051 
      if ftype == TType.STOP:
11052 
        break
11053 
      if fid == 1:
11054 
        if ftype == TType.I64:
3064 chandransh 11055 
          self.orderId = iprot.readI64();
759 chandransh 11056 
        else:
11057 
          iprot.skip(ftype)
11058 
      else:
11059 
        iprot.skip(ftype)
11060 
      iprot.readFieldEnd()
11061 
    iprot.readStructEnd()
11062 
 
11063 
  def write(self, oprot):
11064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11066 
      return
3064 chandransh 11067 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 11068 
    if self.orderId is not None:
3064 chandransh 11069 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11070 
      oprot.writeI64(self.orderId)
759 chandransh 11071 
      oprot.writeFieldEnd()
11072 
    oprot.writeFieldStop()
11073 
    oprot.writeStructEnd()
11074 
 
3431 rajveer 11075 
  def validate(self):
11076 
    return
11077 
 
11078 
 
759 chandransh 11079 
  def __repr__(self):
11080 
    L = ['%s=%r' % (key, value)
11081 
      for key, value in self.__dict__.iteritems()]
11082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11083 
 
11084 
  def __eq__(self, other):
11085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11086 
 
11087 
  def __ne__(self, other):
11088 
    return not (self == other)
11089 
 
3064 chandransh 11090 
class verifyOrder_result:
759 chandransh 11091 
  """
11092 
  Attributes:
11093 
   - success
11094 
   - ex
11095 
  """
11096 
 
11097 
  thrift_spec = (
11098 
    (0, TType.BOOL, 'success', None, None, ), # 0
11099 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11100 
  )
11101 
 
11102 
  def __init__(self, success=None, ex=None,):
11103 
    self.success = success
11104 
    self.ex = ex
11105 
 
11106 
  def read(self, iprot):
11107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11109 
      return
11110 
    iprot.readStructBegin()
11111 
    while True:
11112 
      (fname, ftype, fid) = iprot.readFieldBegin()
11113 
      if ftype == TType.STOP:
11114 
        break
11115 
      if fid == 0:
11116 
        if ftype == TType.BOOL:
11117 
          self.success = iprot.readBool();
11118 
        else:
11119 
          iprot.skip(ftype)
11120 
      elif fid == 1:
11121 
        if ftype == TType.STRUCT:
11122 
          self.ex = TransactionServiceException()
11123 
          self.ex.read(iprot)
11124 
        else:
11125 
          iprot.skip(ftype)
11126 
      else:
11127 
        iprot.skip(ftype)
11128 
      iprot.readFieldEnd()
11129 
    iprot.readStructEnd()
11130 
 
11131 
  def write(self, oprot):
11132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11134 
      return
3064 chandransh 11135 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 11136 
    if self.success is not None:
759 chandransh 11137 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11138 
      oprot.writeBool(self.success)
11139 
      oprot.writeFieldEnd()
3431 rajveer 11140 
    if self.ex is not None:
759 chandransh 11141 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11142 
      self.ex.write(oprot)
11143 
      oprot.writeFieldEnd()
11144 
    oprot.writeFieldStop()
11145 
    oprot.writeStructEnd()
11146 
 
3431 rajveer 11147 
  def validate(self):
11148 
    return
11149 
 
11150 
 
759 chandransh 11151 
  def __repr__(self):
11152 
    L = ['%s=%r' % (key, value)
11153 
      for key, value in self.__dict__.iteritems()]
11154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11155 
 
11156 
  def __eq__(self, other):
11157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11158 
 
11159 
  def __ne__(self, other):
11160 
    return not (self == other)
11161 
 
3064 chandransh 11162 
class acceptOrder_args:
1113 chandransh 11163 
  """
11164 
  Attributes:
3064 chandransh 11165 
   - orderId
1113 chandransh 11166 
  """
11167 
 
11168 
  thrift_spec = (
11169 
    None, # 0
3064 chandransh 11170 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 11171 
  )
11172 
 
3064 chandransh 11173 
  def __init__(self, orderId=None,):
11174 
    self.orderId = orderId
1113 chandransh 11175 
 
11176 
  def read(self, iprot):
11177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11179 
      return
11180 
    iprot.readStructBegin()
11181 
    while True:
11182 
      (fname, ftype, fid) = iprot.readFieldBegin()
11183 
      if ftype == TType.STOP:
11184 
        break
11185 
      if fid == 1:
11186 
        if ftype == TType.I64:
3064 chandransh 11187 
          self.orderId = iprot.readI64();
1113 chandransh 11188 
        else:
11189 
          iprot.skip(ftype)
11190 
      else:
11191 
        iprot.skip(ftype)
11192 
      iprot.readFieldEnd()
11193 
    iprot.readStructEnd()
11194 
 
11195 
  def write(self, oprot):
11196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11198 
      return
3064 chandransh 11199 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 11200 
    if self.orderId is not None:
3064 chandransh 11201 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11202 
      oprot.writeI64(self.orderId)
1113 chandransh 11203 
      oprot.writeFieldEnd()
11204 
    oprot.writeFieldStop()
11205 
    oprot.writeStructEnd()
11206 
 
3431 rajveer 11207 
  def validate(self):
11208 
    return
11209 
 
11210 
 
1113 chandransh 11211 
  def __repr__(self):
11212 
    L = ['%s=%r' % (key, value)
11213 
      for key, value in self.__dict__.iteritems()]
11214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11215 
 
11216 
  def __eq__(self, other):
11217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11218 
 
11219 
  def __ne__(self, other):
11220 
    return not (self == other)
11221 
 
3064 chandransh 11222 
class acceptOrder_result:
1113 chandransh 11223 
  """
11224 
  Attributes:
11225 
   - success
11226 
   - ex
11227 
  """
11228 
 
11229 
  thrift_spec = (
3064 chandransh 11230 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 11231 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11232 
  )
11233 
 
11234 
  def __init__(self, success=None, ex=None,):
11235 
    self.success = success
11236 
    self.ex = ex
11237 
 
11238 
  def read(self, iprot):
11239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11241 
      return
11242 
    iprot.readStructBegin()
11243 
    while True:
11244 
      (fname, ftype, fid) = iprot.readFieldBegin()
11245 
      if ftype == TType.STOP:
11246 
        break
11247 
      if fid == 0:
3064 chandransh 11248 
        if ftype == TType.BOOL:
11249 
          self.success = iprot.readBool();
1113 chandransh 11250 
        else:
11251 
          iprot.skip(ftype)
11252 
      elif fid == 1:
11253 
        if ftype == TType.STRUCT:
11254 
          self.ex = TransactionServiceException()
11255 
          self.ex.read(iprot)
11256 
        else:
11257 
          iprot.skip(ftype)
11258 
      else:
11259 
        iprot.skip(ftype)
11260 
      iprot.readFieldEnd()
11261 
    iprot.readStructEnd()
11262 
 
11263 
  def write(self, oprot):
11264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11266 
      return
3064 chandransh 11267 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 11268 
    if self.success is not None:
3064 chandransh 11269 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11270 
      oprot.writeBool(self.success)
1113 chandransh 11271 
      oprot.writeFieldEnd()
3431 rajveer 11272 
    if self.ex is not None:
1113 chandransh 11273 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11274 
      self.ex.write(oprot)
11275 
      oprot.writeFieldEnd()
11276 
    oprot.writeFieldStop()
11277 
    oprot.writeStructEnd()
11278 
 
3431 rajveer 11279 
  def validate(self):
11280 
    return
11281 
 
11282 
 
1113 chandransh 11283 
  def __repr__(self):
11284 
    L = ['%s=%r' % (key, value)
11285 
      for key, value in self.__dict__.iteritems()]
11286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11287 
 
11288 
  def __eq__(self, other):
11289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11290 
 
11291 
  def __ne__(self, other):
11292 
    return not (self == other)
11293 
 
3064 chandransh 11294 
class addBillingDetails_args:
1135 chandransh 11295 
  """
11296 
  Attributes:
3064 chandransh 11297 
   - orderId
11298 
   - invoice_number
4658 mandeep.dh 11299 
   - serialNumber
4283 anupam.sin 11300 
   - itemNumber
3064 chandransh 11301 
   - billed_by
4264 rajveer 11302 
   - jacketNumber
4283 anupam.sin 11303 
   - billingType
5110 mandeep.dh 11304 
   - fulfilmentWarehouseId
4763 rajveer 11305 
   - authorize
1135 chandransh 11306 
  """
11307 
 
11308 
  thrift_spec = (
11309 
    None, # 0
3064 chandransh 11310 
    (1, TType.I64, 'orderId', None, None, ), # 1
11311 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 11312 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 11313 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
11314 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
11315 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
11316 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 11317 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 11318 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 11319 
  )
11320 
 
5110 mandeep.dh 11321 
  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 11322 
    self.orderId = orderId
11323 
    self.invoice_number = invoice_number
4658 mandeep.dh 11324 
    self.serialNumber = serialNumber
4283 anupam.sin 11325 
    self.itemNumber = itemNumber
3064 chandransh 11326 
    self.billed_by = billed_by
4264 rajveer 11327 
    self.jacketNumber = jacketNumber
4283 anupam.sin 11328 
    self.billingType = billingType
5110 mandeep.dh 11329 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 11330 
    self.authorize = authorize
1135 chandransh 11331 
 
11332 
  def read(self, iprot):
11333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11335 
      return
11336 
    iprot.readStructBegin()
11337 
    while True:
11338 
      (fname, ftype, fid) = iprot.readFieldBegin()
11339 
      if ftype == TType.STOP:
11340 
        break
11341 
      if fid == 1:
11342 
        if ftype == TType.I64:
3064 chandransh 11343 
          self.orderId = iprot.readI64();
1135 chandransh 11344 
        else:
11345 
          iprot.skip(ftype)
11346 
      elif fid == 2:
3064 chandransh 11347 
        if ftype == TType.STRING:
11348 
          self.invoice_number = iprot.readString();
1135 chandransh 11349 
        else:
11350 
          iprot.skip(ftype)
3064 chandransh 11351 
      elif fid == 3:
4658 mandeep.dh 11352 
        if ftype == TType.STRING:
11353 
          self.serialNumber = iprot.readString();
3064 chandransh 11354 
        else:
11355 
          iprot.skip(ftype)
11356 
      elif fid == 4:
11357 
        if ftype == TType.STRING:
11358 
          self.itemNumber = iprot.readString();
11359 
        else:
11360 
          iprot.skip(ftype)
11361 
      elif fid == 5:
11362 
        if ftype == TType.STRING:
4283 anupam.sin 11363 
          self.billed_by = iprot.readString();
3064 chandransh 11364 
        else:
11365 
          iprot.skip(ftype)
11366 
      elif fid == 6:
11367 
        if ftype == TType.I64:
4283 anupam.sin 11368 
          self.jacketNumber = iprot.readI64();
11369 
        else:
11370 
          iprot.skip(ftype)
11371 
      elif fid == 7:
11372 
        if ftype == TType.I64:
3064 chandransh 11373 
          self.billingType = iprot.readI64();
11374 
        else:
11375 
          iprot.skip(ftype)
4283 anupam.sin 11376 
      elif fid == 8:
11377 
        if ftype == TType.I64:
5110 mandeep.dh 11378 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 11379 
        else:
11380 
          iprot.skip(ftype)
4763 rajveer 11381 
      elif fid == 9:
11382 
        if ftype == TType.BOOL:
11383 
          self.authorize = iprot.readBool();
11384 
        else:
11385 
          iprot.skip(ftype)
1246 chandransh 11386 
      else:
11387 
        iprot.skip(ftype)
11388 
      iprot.readFieldEnd()
11389 
    iprot.readStructEnd()
11390 
 
11391 
  def write(self, oprot):
11392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11394 
      return
4283 anupam.sin 11395 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 11396 
    if self.orderId is not None:
3064 chandransh 11397 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11398 
      oprot.writeI64(self.orderId)
1246 chandransh 11399 
      oprot.writeFieldEnd()
4283 anupam.sin 11400 
    if self.invoice_number is not None:
11401 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
11402 
      oprot.writeString(self.invoice_number)
1246 chandransh 11403 
      oprot.writeFieldEnd()
4658 mandeep.dh 11404 
    if self.serialNumber is not None:
11405 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
11406 
      oprot.writeString(self.serialNumber)
3064 chandransh 11407 
      oprot.writeFieldEnd()
3431 rajveer 11408 
    if self.itemNumber is not None:
3064 chandransh 11409 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
11410 
      oprot.writeString(self.itemNumber)
11411 
      oprot.writeFieldEnd()
4283 anupam.sin 11412 
    if self.billed_by is not None:
11413 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
11414 
      oprot.writeString(self.billed_by)
3064 chandransh 11415 
      oprot.writeFieldEnd()
4283 anupam.sin 11416 
    if self.jacketNumber is not None:
11417 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
11418 
      oprot.writeI64(self.jacketNumber)
11419 
      oprot.writeFieldEnd()
3431 rajveer 11420 
    if self.billingType is not None:
4283 anupam.sin 11421 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 11422 
      oprot.writeI64(self.billingType)
11423 
      oprot.writeFieldEnd()
5110 mandeep.dh 11424 
    if self.fulfilmentWarehouseId is not None:
11425 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
11426 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 11427 
      oprot.writeFieldEnd()
4763 rajveer 11428 
    if self.authorize is not None:
11429 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
11430 
      oprot.writeBool(self.authorize)
11431 
      oprot.writeFieldEnd()
1246 chandransh 11432 
    oprot.writeFieldStop()
11433 
    oprot.writeStructEnd()
11434 
 
3431 rajveer 11435 
  def validate(self):
11436 
    return
11437 
 
11438 
 
1246 chandransh 11439 
  def __repr__(self):
11440 
    L = ['%s=%r' % (key, value)
11441 
      for key, value in self.__dict__.iteritems()]
11442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11443 
 
11444 
  def __eq__(self, other):
11445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11446 
 
11447 
  def __ne__(self, other):
11448 
    return not (self == other)
11449 
 
4283 anupam.sin 11450 
class addBillingDetails_result:
1246 chandransh 11451 
  """
11452 
  Attributes:
3064 chandransh 11453 
   - success
1246 chandransh 11454 
   - ex
11455 
  """
11456 
 
11457 
  thrift_spec = (
3064 chandransh 11458 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 11459 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11460 
  )
11461 
 
3064 chandransh 11462 
  def __init__(self, success=None, ex=None,):
11463 
    self.success = success
1246 chandransh 11464 
    self.ex = ex
11465 
 
11466 
  def read(self, iprot):
11467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11469 
      return
11470 
    iprot.readStructBegin()
11471 
    while True:
11472 
      (fname, ftype, fid) = iprot.readFieldBegin()
11473 
      if ftype == TType.STOP:
11474 
        break
3064 chandransh 11475 
      if fid == 0:
11476 
        if ftype == TType.BOOL:
11477 
          self.success = iprot.readBool();
11478 
        else:
11479 
          iprot.skip(ftype)
11480 
      elif fid == 1:
1246 chandransh 11481 
        if ftype == TType.STRUCT:
11482 
          self.ex = TransactionServiceException()
11483 
          self.ex.read(iprot)
11484 
        else:
11485 
          iprot.skip(ftype)
11486 
      else:
11487 
        iprot.skip(ftype)
11488 
      iprot.readFieldEnd()
11489 
    iprot.readStructEnd()
11490 
 
11491 
  def write(self, oprot):
11492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11494 
      return
4283 anupam.sin 11495 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 11496 
    if self.success is not None:
3064 chandransh 11497 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11498 
      oprot.writeBool(self.success)
11499 
      oprot.writeFieldEnd()
3431 rajveer 11500 
    if self.ex is not None:
1246 chandransh 11501 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11502 
      self.ex.write(oprot)
11503 
      oprot.writeFieldEnd()
11504 
    oprot.writeFieldStop()
11505 
    oprot.writeStructEnd()
11506 
 
3431 rajveer 11507 
  def validate(self):
11508 
    return
11509 
 
11510 
 
1246 chandransh 11511 
  def __repr__(self):
11512 
    L = ['%s=%r' % (key, value)
11513 
      for key, value in self.__dict__.iteritems()]
11514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11515 
 
11516 
  def __eq__(self, other):
11517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11518 
 
11519 
  def __ne__(self, other):
11520 
    return not (self == other)
11521 
 
4579 rajveer 11522 
class addInvoiceNumber_args:
11523 
  """
11524 
  Attributes:
11525 
   - orderId
11526 
   - invoiceNumber
4763 rajveer 11527 
   - color
4579 rajveer 11528 
  """
11529 
 
11530 
  thrift_spec = (
11531 
    None, # 0
11532 
    (1, TType.I64, 'orderId', None, None, ), # 1
11533 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 11534 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 11535 
  )
11536 
 
4763 rajveer 11537 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 11538 
    self.orderId = orderId
11539 
    self.invoiceNumber = invoiceNumber
4763 rajveer 11540 
    self.color = color
4579 rajveer 11541 
 
11542 
  def read(self, iprot):
11543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11545 
      return
11546 
    iprot.readStructBegin()
11547 
    while True:
11548 
      (fname, ftype, fid) = iprot.readFieldBegin()
11549 
      if ftype == TType.STOP:
11550 
        break
11551 
      if fid == 1:
11552 
        if ftype == TType.I64:
11553 
          self.orderId = iprot.readI64();
11554 
        else:
11555 
          iprot.skip(ftype)
11556 
      elif fid == 2:
11557 
        if ftype == TType.STRING:
11558 
          self.invoiceNumber = iprot.readString();
11559 
        else:
11560 
          iprot.skip(ftype)
4763 rajveer 11561 
      elif fid == 3:
11562 
        if ftype == TType.STRING:
11563 
          self.color = iprot.readString();
11564 
        else:
11565 
          iprot.skip(ftype)
4579 rajveer 11566 
      else:
11567 
        iprot.skip(ftype)
11568 
      iprot.readFieldEnd()
11569 
    iprot.readStructEnd()
11570 
 
11571 
  def write(self, oprot):
11572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11574 
      return
11575 
    oprot.writeStructBegin('addInvoiceNumber_args')
11576 
    if self.orderId is not None:
11577 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11578 
      oprot.writeI64(self.orderId)
11579 
      oprot.writeFieldEnd()
11580 
    if self.invoiceNumber is not None:
11581 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
11582 
      oprot.writeString(self.invoiceNumber)
11583 
      oprot.writeFieldEnd()
4763 rajveer 11584 
    if self.color is not None:
11585 
      oprot.writeFieldBegin('color', TType.STRING, 3)
11586 
      oprot.writeString(self.color)
11587 
      oprot.writeFieldEnd()
4579 rajveer 11588 
    oprot.writeFieldStop()
11589 
    oprot.writeStructEnd()
11590 
 
11591 
  def validate(self):
11592 
    return
11593 
 
11594 
 
11595 
  def __repr__(self):
11596 
    L = ['%s=%r' % (key, value)
11597 
      for key, value in self.__dict__.iteritems()]
11598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11599 
 
11600 
  def __eq__(self, other):
11601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11602 
 
11603 
  def __ne__(self, other):
11604 
    return not (self == other)
11605 
 
11606 
class addInvoiceNumber_result:
11607 
  """
11608 
  Attributes:
11609 
   - ex
11610 
  """
11611 
 
11612 
  thrift_spec = (
11613 
    None, # 0
11614 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11615 
  )
11616 
 
11617 
  def __init__(self, ex=None,):
11618 
    self.ex = ex
11619 
 
11620 
  def read(self, iprot):
11621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11623 
      return
11624 
    iprot.readStructBegin()
11625 
    while True:
11626 
      (fname, ftype, fid) = iprot.readFieldBegin()
11627 
      if ftype == TType.STOP:
11628 
        break
11629 
      if fid == 1:
11630 
        if ftype == TType.STRUCT:
11631 
          self.ex = TransactionServiceException()
11632 
          self.ex.read(iprot)
11633 
        else:
11634 
          iprot.skip(ftype)
11635 
      else:
11636 
        iprot.skip(ftype)
11637 
      iprot.readFieldEnd()
11638 
    iprot.readStructEnd()
11639 
 
11640 
  def write(self, oprot):
11641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11643 
      return
11644 
    oprot.writeStructBegin('addInvoiceNumber_result')
11645 
    if self.ex is not None:
11646 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11647 
      self.ex.write(oprot)
11648 
      oprot.writeFieldEnd()
11649 
    oprot.writeFieldStop()
11650 
    oprot.writeStructEnd()
11651 
 
11652 
  def validate(self):
11653 
    return
11654 
 
11655 
 
11656 
  def __repr__(self):
11657 
    L = ['%s=%r' % (key, value)
11658 
      for key, value in self.__dict__.iteritems()]
11659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11660 
 
11661 
  def __eq__(self, other):
11662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11663 
 
11664 
  def __ne__(self, other):
11665 
    return not (self == other)
11666 
 
4910 phani.kuma 11667 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 11668 
  """
11669 
  Attributes:
3064 chandransh 11670 
   - warehouseId
1408 ankur.sing 11671 
   - providerId
3064 chandransh 11672 
   - cod
4910 phani.kuma 11673 
   - orderIds
1408 ankur.sing 11674 
  """
11675 
 
11676 
  thrift_spec = (
11677 
    None, # 0
3064 chandransh 11678 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11679 
    (2, TType.I64, 'providerId', None, None, ), # 2
11680 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 11681 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 11682 
  )
11683 
 
4910 phani.kuma 11684 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 11685 
    self.warehouseId = warehouseId
1408 ankur.sing 11686 
    self.providerId = providerId
3064 chandransh 11687 
    self.cod = cod
4910 phani.kuma 11688 
    self.orderIds = orderIds
1408 ankur.sing 11689 
 
11690 
  def read(self, iprot):
11691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11693 
      return
11694 
    iprot.readStructBegin()
11695 
    while True:
11696 
      (fname, ftype, fid) = iprot.readFieldBegin()
11697 
      if ftype == TType.STOP:
11698 
        break
11699 
      if fid == 1:
11700 
        if ftype == TType.I64:
3064 chandransh 11701 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 11702 
        else:
11703 
          iprot.skip(ftype)
11704 
      elif fid == 2:
11705 
        if ftype == TType.I64:
3064 chandransh 11706 
          self.providerId = iprot.readI64();
1408 ankur.sing 11707 
        else:
11708 
          iprot.skip(ftype)
3064 chandransh 11709 
      elif fid == 3:
11710 
        if ftype == TType.BOOL:
11711 
          self.cod = iprot.readBool();
11712 
        else:
11713 
          iprot.skip(ftype)
4910 phani.kuma 11714 
      elif fid == 4:
11715 
        if ftype == TType.LIST:
11716 
          self.orderIds = []
5031 varun.gupt 11717 
          (_etype213, _size210) = iprot.readListBegin()
11718 
          for _i214 in xrange(_size210):
11719 
            _elem215 = iprot.readI64();
11720 
            self.orderIds.append(_elem215)
4910 phani.kuma 11721 
          iprot.readListEnd()
11722 
        else:
11723 
          iprot.skip(ftype)
1408 ankur.sing 11724 
      else:
11725 
        iprot.skip(ftype)
11726 
      iprot.readFieldEnd()
11727 
    iprot.readStructEnd()
11728 
 
11729 
  def write(self, oprot):
11730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11732 
      return
4910 phani.kuma 11733 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 11734 
    if self.warehouseId is not None:
3064 chandransh 11735 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11736 
      oprot.writeI64(self.warehouseId)
11737 
      oprot.writeFieldEnd()
3431 rajveer 11738 
    if self.providerId is not None:
3064 chandransh 11739 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 11740 
      oprot.writeI64(self.providerId)
11741 
      oprot.writeFieldEnd()
3431 rajveer 11742 
    if self.cod is not None:
3064 chandransh 11743 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
11744 
      oprot.writeBool(self.cod)
1408 ankur.sing 11745 
      oprot.writeFieldEnd()
4910 phani.kuma 11746 
    if self.orderIds is not None:
11747 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
11748 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5031 varun.gupt 11749 
      for iter216 in self.orderIds:
11750 
        oprot.writeI64(iter216)
4910 phani.kuma 11751 
      oprot.writeListEnd()
11752 
      oprot.writeFieldEnd()
1408 ankur.sing 11753 
    oprot.writeFieldStop()
11754 
    oprot.writeStructEnd()
11755 
 
3431 rajveer 11756 
  def validate(self):
11757 
    return
11758 
 
11759 
 
1408 ankur.sing 11760 
  def __repr__(self):
11761 
    L = ['%s=%r' % (key, value)
11762 
      for key, value in self.__dict__.iteritems()]
11763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11764 
 
11765 
  def __eq__(self, other):
11766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11767 
 
11768 
  def __ne__(self, other):
11769 
    return not (self == other)
11770 
 
4910 phani.kuma 11771 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 11772 
  """
11773 
  Attributes:
11774 
   - success
3064 chandransh 11775 
   - ex
1408 ankur.sing 11776 
  """
11777 
 
11778 
  thrift_spec = (
3064 chandransh 11779 
    (0, TType.BOOL, 'success', None, None, ), # 0
11780 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 11781 
  )
11782 
 
3064 chandransh 11783 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 11784 
    self.success = success
3064 chandransh 11785 
    self.ex = ex
1408 ankur.sing 11786 
 
11787 
  def read(self, iprot):
11788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11790 
      return
11791 
    iprot.readStructBegin()
11792 
    while True:
11793 
      (fname, ftype, fid) = iprot.readFieldBegin()
11794 
      if ftype == TType.STOP:
11795 
        break
11796 
      if fid == 0:
3064 chandransh 11797 
        if ftype == TType.BOOL:
11798 
          self.success = iprot.readBool();
1408 ankur.sing 11799 
        else:
11800 
          iprot.skip(ftype)
3064 chandransh 11801 
      elif fid == 1:
11802 
        if ftype == TType.STRUCT:
11803 
          self.ex = TransactionServiceException()
11804 
          self.ex.read(iprot)
11805 
        else:
11806 
          iprot.skip(ftype)
1408 ankur.sing 11807 
      else:
11808 
        iprot.skip(ftype)
11809 
      iprot.readFieldEnd()
11810 
    iprot.readStructEnd()
11811 
 
11812 
  def write(self, oprot):
11813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11815 
      return
4910 phani.kuma 11816 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 11817 
    if self.success is not None:
3064 chandransh 11818 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11819 
      oprot.writeBool(self.success)
1408 ankur.sing 11820 
      oprot.writeFieldEnd()
3431 rajveer 11821 
    if self.ex is not None:
3064 chandransh 11822 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11823 
      self.ex.write(oprot)
11824 
      oprot.writeFieldEnd()
1408 ankur.sing 11825 
    oprot.writeFieldStop()
11826 
    oprot.writeStructEnd()
11827 
 
3431 rajveer 11828 
  def validate(self):
11829 
    return
11830 
 
11831 
 
1408 ankur.sing 11832 
  def __repr__(self):
11833 
    L = ['%s=%r' % (key, value)
11834 
      for key, value in self.__dict__.iteritems()]
11835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11836 
 
11837 
  def __eq__(self, other):
11838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11839 
 
11840 
  def __ne__(self, other):
11841 
    return not (self == other)
11842 
 
4910 phani.kuma 11843 
class markOrdersAsPickedUp_args:
4410 rajveer 11844 
  """
11845 
  Attributes:
11846 
   - providerId
4910 phani.kuma 11847 
   - pickupDetails
4410 rajveer 11848 
  """
11849 
 
11850 
  thrift_spec = (
11851 
    None, # 0
4910 phani.kuma 11852 
    (1, TType.I64, 'providerId', None, None, ), # 1
11853 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 11854 
  )
11855 
 
4910 phani.kuma 11856 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 11857 
    self.providerId = providerId
4910 phani.kuma 11858 
    self.pickupDetails = pickupDetails
4410 rajveer 11859 
 
11860 
  def read(self, iprot):
11861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11863 
      return
11864 
    iprot.readStructBegin()
11865 
    while True:
11866 
      (fname, ftype, fid) = iprot.readFieldBegin()
11867 
      if ftype == TType.STOP:
11868 
        break
11869 
      if fid == 1:
11870 
        if ftype == TType.I64:
4910 phani.kuma 11871 
          self.providerId = iprot.readI64();
4410 rajveer 11872 
        else:
11873 
          iprot.skip(ftype)
11874 
      elif fid == 2:
4910 phani.kuma 11875 
        if ftype == TType.MAP:
11876 
          self.pickupDetails = {}
5031 varun.gupt 11877 
          (_ktype218, _vtype219, _size217 ) = iprot.readMapBegin()
11878 
          for _i221 in xrange(_size217):
11879 
            _key222 = iprot.readString();
11880 
            _val223 = iprot.readString();
11881 
            self.pickupDetails[_key222] = _val223
4910 phani.kuma 11882 
          iprot.readMapEnd()
4410 rajveer 11883 
        else:
11884 
          iprot.skip(ftype)
11885 
      else:
11886 
        iprot.skip(ftype)
11887 
      iprot.readFieldEnd()
11888 
    iprot.readStructEnd()
11889 
 
11890 
  def write(self, oprot):
11891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11893 
      return
4910 phani.kuma 11894 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 11895 
    if self.providerId is not None:
4910 phani.kuma 11896 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 11897 
      oprot.writeI64(self.providerId)
11898 
      oprot.writeFieldEnd()
4910 phani.kuma 11899 
    if self.pickupDetails is not None:
11900 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11901 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 11902 
      for kiter224,viter225 in self.pickupDetails.items():
11903 
        oprot.writeString(kiter224)
11904 
        oprot.writeString(viter225)
4910 phani.kuma 11905 
      oprot.writeMapEnd()
4410 rajveer 11906 
      oprot.writeFieldEnd()
11907 
    oprot.writeFieldStop()
11908 
    oprot.writeStructEnd()
11909 
 
11910 
  def validate(self):
11911 
    return
11912 
 
11913 
 
11914 
  def __repr__(self):
11915 
    L = ['%s=%r' % (key, value)
11916 
      for key, value in self.__dict__.iteritems()]
11917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11918 
 
11919 
  def __eq__(self, other):
11920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11921 
 
11922 
  def __ne__(self, other):
11923 
    return not (self == other)
11924 
 
4910 phani.kuma 11925 
class markOrdersAsPickedUp_result:
4410 rajveer 11926 
  """
11927 
  Attributes:
11928 
   - ex
11929 
  """
11930 
 
11931 
  thrift_spec = (
4910 phani.kuma 11932 
    None, # 0
4410 rajveer 11933 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11934 
  )
11935 
 
4910 phani.kuma 11936 
  def __init__(self, ex=None,):
4410 rajveer 11937 
    self.ex = ex
11938 
 
11939 
  def read(self, iprot):
11940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11942 
      return
11943 
    iprot.readStructBegin()
11944 
    while True:
11945 
      (fname, ftype, fid) = iprot.readFieldBegin()
11946 
      if ftype == TType.STOP:
11947 
        break
4910 phani.kuma 11948 
      if fid == 1:
4410 rajveer 11949 
        if ftype == TType.STRUCT:
11950 
          self.ex = TransactionServiceException()
11951 
          self.ex.read(iprot)
11952 
        else:
11953 
          iprot.skip(ftype)
11954 
      else:
11955 
        iprot.skip(ftype)
11956 
      iprot.readFieldEnd()
11957 
    iprot.readStructEnd()
11958 
 
11959 
  def write(self, oprot):
11960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11962 
      return
4910 phani.kuma 11963 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 11964 
    if self.ex is not None:
11965 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11966 
      self.ex.write(oprot)
11967 
      oprot.writeFieldEnd()
11968 
    oprot.writeFieldStop()
11969 
    oprot.writeStructEnd()
11970 
 
11971 
  def validate(self):
11972 
    return
11973 
 
11974 
 
11975 
  def __repr__(self):
11976 
    L = ['%s=%r' % (key, value)
11977 
      for key, value in self.__dict__.iteritems()]
11978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11979 
 
11980 
  def __eq__(self, other):
11981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11982 
 
11983 
  def __ne__(self, other):
11984 
    return not (self == other)
11985 
 
4910 phani.kuma 11986 
class getOrdersNotPickedUp_args:
304 ashish 11987 
  """
11988 
  Attributes:
3064 chandransh 11989 
   - providerId
304 ashish 11990 
  """
94 ashish 11991 
 
304 ashish 11992 
  thrift_spec = (
11993 
    None, # 0
3064 chandransh 11994 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 11995 
  )
11996 
 
4910 phani.kuma 11997 
  def __init__(self, providerId=None,):
3064 chandransh 11998 
    self.providerId = providerId
304 ashish 11999 
 
12000 
  def read(self, iprot):
12001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12003 
      return
12004 
    iprot.readStructBegin()
12005 
    while True:
12006 
      (fname, ftype, fid) = iprot.readFieldBegin()
12007 
      if ftype == TType.STOP:
12008 
        break
12009 
      if fid == 1:
12010 
        if ftype == TType.I64:
3064 chandransh 12011 
          self.providerId = iprot.readI64();
304 ashish 12012 
        else:
12013 
          iprot.skip(ftype)
12014 
      else:
12015 
        iprot.skip(ftype)
12016 
      iprot.readFieldEnd()
12017 
    iprot.readStructEnd()
12018 
 
12019 
  def write(self, oprot):
12020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12022 
      return
4910 phani.kuma 12023 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 12024 
    if self.providerId is not None:
3064 chandransh 12025 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12026 
      oprot.writeI64(self.providerId)
304 ashish 12027 
      oprot.writeFieldEnd()
12028 
    oprot.writeFieldStop()
12029 
    oprot.writeStructEnd()
12030 
 
3431 rajveer 12031 
  def validate(self):
12032 
    return
12033 
 
12034 
 
304 ashish 12035 
  def __repr__(self):
12036 
    L = ['%s=%r' % (key, value)
12037 
      for key, value in self.__dict__.iteritems()]
12038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12039 
 
12040 
  def __eq__(self, other):
12041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12042 
 
12043 
  def __ne__(self, other):
12044 
    return not (self == other)
12045 
 
4910 phani.kuma 12046 
class getOrdersNotPickedUp_result:
304 ashish 12047 
  """
12048 
  Attributes:
12049 
   - success
12050 
  """
12051 
 
12052 
  thrift_spec = (
3064 chandransh 12053 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 12054 
  )
12055 
 
4910 phani.kuma 12056 
  def __init__(self, success=None,):
304 ashish 12057 
    self.success = success
12058 
 
12059 
  def read(self, iprot):
12060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12062 
      return
12063 
    iprot.readStructBegin()
12064 
    while True:
12065 
      (fname, ftype, fid) = iprot.readFieldBegin()
12066 
      if ftype == TType.STOP:
12067 
        break
12068 
      if fid == 0:
12069 
        if ftype == TType.LIST:
12070 
          self.success = []
5031 varun.gupt 12071 
          (_etype229, _size226) = iprot.readListBegin()
12072 
          for _i230 in xrange(_size226):
12073 
            _elem231 = Order()
12074 
            _elem231.read(iprot)
12075 
            self.success.append(_elem231)
304 ashish 12076 
          iprot.readListEnd()
12077 
        else:
12078 
          iprot.skip(ftype)
12079 
      else:
12080 
        iprot.skip(ftype)
12081 
      iprot.readFieldEnd()
12082 
    iprot.readStructEnd()
12083 
 
12084 
  def write(self, oprot):
12085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12087 
      return
4910 phani.kuma 12088 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 12089 
    if self.success is not None:
304 ashish 12090 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12091 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12092 
      for iter232 in self.success:
12093 
        iter232.write(oprot)
304 ashish 12094 
      oprot.writeListEnd()
12095 
      oprot.writeFieldEnd()
12096 
    oprot.writeFieldStop()
12097 
    oprot.writeStructEnd()
12098 
 
3431 rajveer 12099 
  def validate(self):
12100 
    return
12101 
 
12102 
 
304 ashish 12103 
  def __repr__(self):
12104 
    L = ['%s=%r' % (key, value)
12105 
      for key, value in self.__dict__.iteritems()]
12106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12107 
 
12108 
  def __eq__(self, other):
12109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12110 
 
12111 
  def __ne__(self, other):
12112 
    return not (self == other)
12113 
 
3064 chandransh 12114 
class markOrdersAsDelivered_args:
304 ashish 12115 
  """
12116 
  Attributes:
3064 chandransh 12117 
   - providerId
12118 
   - deliveredOrders
304 ashish 12119 
  """
12120 
 
12121 
  thrift_spec = (
12122 
    None, # 0
3064 chandransh 12123 
    (1, TType.I64, 'providerId', None, None, ), # 1
12124 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 12125 
  )
12126 
 
3064 chandransh 12127 
  def __init__(self, providerId=None, deliveredOrders=None,):
12128 
    self.providerId = providerId
12129 
    self.deliveredOrders = deliveredOrders
304 ashish 12130 
 
12131 
  def read(self, iprot):
12132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12134 
      return
12135 
    iprot.readStructBegin()
12136 
    while True:
12137 
      (fname, ftype, fid) = iprot.readFieldBegin()
12138 
      if ftype == TType.STOP:
12139 
        break
12140 
      if fid == 1:
12141 
        if ftype == TType.I64:
3064 chandransh 12142 
          self.providerId = iprot.readI64();
304 ashish 12143 
        else:
12144 
          iprot.skip(ftype)
12145 
      elif fid == 2:
3064 chandransh 12146 
        if ftype == TType.MAP:
12147 
          self.deliveredOrders = {}
5031 varun.gupt 12148 
          (_ktype234, _vtype235, _size233 ) = iprot.readMapBegin()
12149 
          for _i237 in xrange(_size233):
12150 
            _key238 = iprot.readString();
12151 
            _val239 = iprot.readString();
12152 
            self.deliveredOrders[_key238] = _val239
3064 chandransh 12153 
          iprot.readMapEnd()
304 ashish 12154 
        else:
12155 
          iprot.skip(ftype)
12156 
      else:
12157 
        iprot.skip(ftype)
12158 
      iprot.readFieldEnd()
12159 
    iprot.readStructEnd()
12160 
 
12161 
  def write(self, oprot):
12162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12164 
      return
3064 chandransh 12165 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 12166 
    if self.providerId is not None:
3064 chandransh 12167 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12168 
      oprot.writeI64(self.providerId)
304 ashish 12169 
      oprot.writeFieldEnd()
3431 rajveer 12170 
    if self.deliveredOrders is not None:
3064 chandransh 12171 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
12172 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
5031 varun.gupt 12173 
      for kiter240,viter241 in self.deliveredOrders.items():
12174 
        oprot.writeString(kiter240)
12175 
        oprot.writeString(viter241)
3064 chandransh 12176 
      oprot.writeMapEnd()
304 ashish 12177 
      oprot.writeFieldEnd()
12178 
    oprot.writeFieldStop()
12179 
    oprot.writeStructEnd()
12180 
 
3431 rajveer 12181 
  def validate(self):
12182 
    return
12183 
 
12184 
 
304 ashish 12185 
  def __repr__(self):
12186 
    L = ['%s=%r' % (key, value)
12187 
      for key, value in self.__dict__.iteritems()]
12188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12189 
 
12190 
  def __eq__(self, other):
12191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12192 
 
12193 
  def __ne__(self, other):
12194 
    return not (self == other)
12195 
 
3064 chandransh 12196 
class markOrdersAsDelivered_result:
12197 
  """
12198 
  Attributes:
12199 
   - ex
12200 
  """
304 ashish 12201 
 
12202 
  thrift_spec = (
3064 chandransh 12203 
    None, # 0
12204 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 12205 
  )
12206 
 
3064 chandransh 12207 
  def __init__(self, ex=None,):
12208 
    self.ex = ex
304 ashish 12209 
 
1596 ankur.sing 12210 
  def read(self, iprot):
12211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12213 
      return
12214 
    iprot.readStructBegin()
12215 
    while True:
12216 
      (fname, ftype, fid) = iprot.readFieldBegin()
12217 
      if ftype == TType.STOP:
12218 
        break
3064 chandransh 12219 
      if fid == 1:
12220 
        if ftype == TType.STRUCT:
12221 
          self.ex = TransactionServiceException()
12222 
          self.ex.read(iprot)
12223 
        else:
12224 
          iprot.skip(ftype)
1596 ankur.sing 12225 
      else:
12226 
        iprot.skip(ftype)
12227 
      iprot.readFieldEnd()
12228 
    iprot.readStructEnd()
12229 
 
12230 
  def write(self, oprot):
12231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12233 
      return
3064 chandransh 12234 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 12235 
    if self.ex is not None:
3064 chandransh 12236 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12237 
      self.ex.write(oprot)
12238 
      oprot.writeFieldEnd()
1596 ankur.sing 12239 
    oprot.writeFieldStop()
12240 
    oprot.writeStructEnd()
12241 
 
3431 rajveer 12242 
  def validate(self):
12243 
    return
12244 
 
12245 
 
1596 ankur.sing 12246 
  def __repr__(self):
12247 
    L = ['%s=%r' % (key, value)
12248 
      for key, value in self.__dict__.iteritems()]
12249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12250 
 
12251 
  def __eq__(self, other):
12252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12253 
 
12254 
  def __ne__(self, other):
12255 
    return not (self == other)
12256 
 
4910 phani.kuma 12257 
class markAsRTOrders_args:
1596 ankur.sing 12258 
  """
12259 
  Attributes:
3064 chandransh 12260 
   - providerId
12261 
   - returnedOrders
1596 ankur.sing 12262 
  """
12263 
 
12264 
  thrift_spec = (
3064 chandransh 12265 
    None, # 0
12266 
    (1, TType.I64, 'providerId', None, None, ), # 1
12267 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 12268 
  )
12269 
 
3064 chandransh 12270 
  def __init__(self, providerId=None, returnedOrders=None,):
12271 
    self.providerId = providerId
12272 
    self.returnedOrders = returnedOrders
1596 ankur.sing 12273 
 
12274 
  def read(self, iprot):
12275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12277 
      return
12278 
    iprot.readStructBegin()
12279 
    while True:
12280 
      (fname, ftype, fid) = iprot.readFieldBegin()
12281 
      if ftype == TType.STOP:
12282 
        break
3064 chandransh 12283 
      if fid == 1:
1596 ankur.sing 12284 
        if ftype == TType.I64:
3064 chandransh 12285 
          self.providerId = iprot.readI64();
1596 ankur.sing 12286 
        else:
12287 
          iprot.skip(ftype)
3064 chandransh 12288 
      elif fid == 2:
12289 
        if ftype == TType.MAP:
12290 
          self.returnedOrders = {}
5031 varun.gupt 12291 
          (_ktype243, _vtype244, _size242 ) = iprot.readMapBegin()
12292 
          for _i246 in xrange(_size242):
12293 
            _key247 = iprot.readString();
12294 
            _val248 = iprot.readString();
12295 
            self.returnedOrders[_key247] = _val248
3064 chandransh 12296 
          iprot.readMapEnd()
12297 
        else:
12298 
          iprot.skip(ftype)
1596 ankur.sing 12299 
      else:
12300 
        iprot.skip(ftype)
12301 
      iprot.readFieldEnd()
12302 
    iprot.readStructEnd()
12303 
 
12304 
  def write(self, oprot):
12305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12307 
      return
4910 phani.kuma 12308 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 12309 
    if self.providerId is not None:
3064 chandransh 12310 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12311 
      oprot.writeI64(self.providerId)
1596 ankur.sing 12312 
      oprot.writeFieldEnd()
3431 rajveer 12313 
    if self.returnedOrders is not None:
3064 chandransh 12314 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
12315 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
5031 varun.gupt 12316 
      for kiter249,viter250 in self.returnedOrders.items():
12317 
        oprot.writeString(kiter249)
12318 
        oprot.writeString(viter250)
3064 chandransh 12319 
      oprot.writeMapEnd()
12320 
      oprot.writeFieldEnd()
1596 ankur.sing 12321 
    oprot.writeFieldStop()
12322 
    oprot.writeStructEnd()
12323 
 
3431 rajveer 12324 
  def validate(self):
12325 
    return
12326 
 
12327 
 
1596 ankur.sing 12328 
  def __repr__(self):
12329 
    L = ['%s=%r' % (key, value)
12330 
      for key, value in self.__dict__.iteritems()]
12331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12332 
 
12333 
  def __eq__(self, other):
12334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12335 
 
12336 
  def __ne__(self, other):
12337 
    return not (self == other)
12338 
 
4910 phani.kuma 12339 
class markAsRTOrders_result:
3064 chandransh 12340 
  """
12341 
  Attributes:
12342 
   - ex
12343 
  """
1596 ankur.sing 12344 
 
1627 ankur.sing 12345 
  thrift_spec = (
3064 chandransh 12346 
    None, # 0
12347 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12348 
  )
12349 
 
3064 chandransh 12350 
  def __init__(self, ex=None,):
12351 
    self.ex = ex
12352 
 
1627 ankur.sing 12353 
  def read(self, iprot):
12354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12356 
      return
12357 
    iprot.readStructBegin()
12358 
    while True:
12359 
      (fname, ftype, fid) = iprot.readFieldBegin()
12360 
      if ftype == TType.STOP:
12361 
        break
3064 chandransh 12362 
      if fid == 1:
12363 
        if ftype == TType.STRUCT:
12364 
          self.ex = TransactionServiceException()
12365 
          self.ex.read(iprot)
12366 
        else:
12367 
          iprot.skip(ftype)
1627 ankur.sing 12368 
      else:
12369 
        iprot.skip(ftype)
12370 
      iprot.readFieldEnd()
12371 
    iprot.readStructEnd()
12372 
 
12373 
  def write(self, oprot):
12374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12376 
      return
4910 phani.kuma 12377 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 12378 
    if self.ex is not None:
3064 chandransh 12379 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12380 
      self.ex.write(oprot)
12381 
      oprot.writeFieldEnd()
1627 ankur.sing 12382 
    oprot.writeFieldStop()
12383 
    oprot.writeStructEnd()
12384 
 
3431 rajveer 12385 
  def validate(self):
12386 
    return
12387 
 
12388 
 
1627 ankur.sing 12389 
  def __repr__(self):
12390 
    L = ['%s=%r' % (key, value)
12391 
      for key, value in self.__dict__.iteritems()]
12392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12393 
 
12394 
  def __eq__(self, other):
12395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12396 
 
12397 
  def __ne__(self, other):
12398 
    return not (self == other)
12399 
 
4910 phani.kuma 12400 
class getRTOrders_args:
12401 
  """
12402 
  Attributes:
12403 
   - providerId
12404 
  """
12405 
 
12406 
  thrift_spec = (
12407 
    None, # 0
12408 
    (1, TType.I64, 'providerId', None, None, ), # 1
12409 
  )
12410 
 
12411 
  def __init__(self, providerId=None,):
12412 
    self.providerId = providerId
12413 
 
12414 
  def read(self, iprot):
12415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12417 
      return
12418 
    iprot.readStructBegin()
12419 
    while True:
12420 
      (fname, ftype, fid) = iprot.readFieldBegin()
12421 
      if ftype == TType.STOP:
12422 
        break
12423 
      if fid == 1:
12424 
        if ftype == TType.I64:
12425 
          self.providerId = iprot.readI64();
12426 
        else:
12427 
          iprot.skip(ftype)
12428 
      else:
12429 
        iprot.skip(ftype)
12430 
      iprot.readFieldEnd()
12431 
    iprot.readStructEnd()
12432 
 
12433 
  def write(self, oprot):
12434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12436 
      return
12437 
    oprot.writeStructBegin('getRTOrders_args')
12438 
    if self.providerId is not None:
12439 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12440 
      oprot.writeI64(self.providerId)
12441 
      oprot.writeFieldEnd()
12442 
    oprot.writeFieldStop()
12443 
    oprot.writeStructEnd()
12444 
 
12445 
  def validate(self):
12446 
    return
12447 
 
12448 
 
12449 
  def __repr__(self):
12450 
    L = ['%s=%r' % (key, value)
12451 
      for key, value in self.__dict__.iteritems()]
12452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12453 
 
12454 
  def __eq__(self, other):
12455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12456 
 
12457 
  def __ne__(self, other):
12458 
    return not (self == other)
12459 
 
12460 
class getRTOrders_result:
12461 
  """
12462 
  Attributes:
12463 
   - success
12464 
  """
12465 
 
12466 
  thrift_spec = (
12467 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12468 
  )
12469 
 
12470 
  def __init__(self, success=None,):
12471 
    self.success = success
12472 
 
12473 
  def read(self, iprot):
12474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12476 
      return
12477 
    iprot.readStructBegin()
12478 
    while True:
12479 
      (fname, ftype, fid) = iprot.readFieldBegin()
12480 
      if ftype == TType.STOP:
12481 
        break
12482 
      if fid == 0:
12483 
        if ftype == TType.LIST:
12484 
          self.success = []
5031 varun.gupt 12485 
          (_etype254, _size251) = iprot.readListBegin()
12486 
          for _i255 in xrange(_size251):
12487 
            _elem256 = Order()
12488 
            _elem256.read(iprot)
12489 
            self.success.append(_elem256)
4910 phani.kuma 12490 
          iprot.readListEnd()
12491 
        else:
12492 
          iprot.skip(ftype)
12493 
      else:
12494 
        iprot.skip(ftype)
12495 
      iprot.readFieldEnd()
12496 
    iprot.readStructEnd()
12497 
 
12498 
  def write(self, oprot):
12499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12501 
      return
12502 
    oprot.writeStructBegin('getRTOrders_result')
12503 
    if self.success is not None:
12504 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12505 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12506 
      for iter257 in self.success:
12507 
        iter257.write(oprot)
4910 phani.kuma 12508 
      oprot.writeListEnd()
12509 
      oprot.writeFieldEnd()
12510 
    oprot.writeFieldStop()
12511 
    oprot.writeStructEnd()
12512 
 
12513 
  def validate(self):
12514 
    return
12515 
 
12516 
 
12517 
  def __repr__(self):
12518 
    L = ['%s=%r' % (key, value)
12519 
      for key, value in self.__dict__.iteritems()]
12520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12521 
 
12522 
  def __eq__(self, other):
12523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12524 
 
12525 
  def __ne__(self, other):
12526 
    return not (self == other)
12527 
 
3064 chandransh 12528 
class updateNonDeliveryReason_args:
1627 ankur.sing 12529 
  """
12530 
  Attributes:
3064 chandransh 12531 
   - providerId
12532 
   - undeliveredOrders
1627 ankur.sing 12533 
  """
12534 
 
12535 
  thrift_spec = (
3064 chandransh 12536 
    None, # 0
12537 
    (1, TType.I64, 'providerId', None, None, ), # 1
12538 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 12539 
  )
12540 
 
3064 chandransh 12541 
  def __init__(self, providerId=None, undeliveredOrders=None,):
12542 
    self.providerId = providerId
12543 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 12544 
 
12545 
  def read(self, iprot):
12546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12548 
      return
12549 
    iprot.readStructBegin()
12550 
    while True:
12551 
      (fname, ftype, fid) = iprot.readFieldBegin()
12552 
      if ftype == TType.STOP:
12553 
        break
3064 chandransh 12554 
      if fid == 1:
1627 ankur.sing 12555 
        if ftype == TType.I64:
3064 chandransh 12556 
          self.providerId = iprot.readI64();
1627 ankur.sing 12557 
        else:
12558 
          iprot.skip(ftype)
3064 chandransh 12559 
      elif fid == 2:
12560 
        if ftype == TType.MAP:
12561 
          self.undeliveredOrders = {}
5031 varun.gupt 12562 
          (_ktype259, _vtype260, _size258 ) = iprot.readMapBegin()
12563 
          for _i262 in xrange(_size258):
12564 
            _key263 = iprot.readString();
12565 
            _val264 = iprot.readString();
12566 
            self.undeliveredOrders[_key263] = _val264
3064 chandransh 12567 
          iprot.readMapEnd()
12568 
        else:
12569 
          iprot.skip(ftype)
1627 ankur.sing 12570 
      else:
12571 
        iprot.skip(ftype)
12572 
      iprot.readFieldEnd()
12573 
    iprot.readStructEnd()
12574 
 
12575 
  def write(self, oprot):
12576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12578 
      return
3064 chandransh 12579 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 12580 
    if self.providerId is not None:
3064 chandransh 12581 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12582 
      oprot.writeI64(self.providerId)
1627 ankur.sing 12583 
      oprot.writeFieldEnd()
3431 rajveer 12584 
    if self.undeliveredOrders is not None:
3064 chandransh 12585 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
12586 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
5031 varun.gupt 12587 
      for kiter265,viter266 in self.undeliveredOrders.items():
12588 
        oprot.writeString(kiter265)
12589 
        oprot.writeString(viter266)
3064 chandransh 12590 
      oprot.writeMapEnd()
12591 
      oprot.writeFieldEnd()
1627 ankur.sing 12592 
    oprot.writeFieldStop()
12593 
    oprot.writeStructEnd()
12594 
 
3431 rajveer 12595 
  def validate(self):
12596 
    return
12597 
 
12598 
 
1627 ankur.sing 12599 
  def __repr__(self):
12600 
    L = ['%s=%r' % (key, value)
12601 
      for key, value in self.__dict__.iteritems()]
12602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12603 
 
12604 
  def __eq__(self, other):
12605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12606 
 
12607 
  def __ne__(self, other):
12608 
    return not (self == other)
12609 
 
3064 chandransh 12610 
class updateNonDeliveryReason_result:
1627 ankur.sing 12611 
  """
12612 
  Attributes:
3064 chandransh 12613 
   - ex
1627 ankur.sing 12614 
  """
12615 
 
12616 
  thrift_spec = (
4910 phani.kuma 12617 
    None, # 0
3064 chandransh 12618 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12619 
  )
12620 
 
4910 phani.kuma 12621 
  def __init__(self, ex=None,):
3064 chandransh 12622 
    self.ex = ex
1627 ankur.sing 12623 
 
12624 
  def read(self, iprot):
12625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12627 
      return
12628 
    iprot.readStructBegin()
12629 
    while True:
12630 
      (fname, ftype, fid) = iprot.readFieldBegin()
12631 
      if ftype == TType.STOP:
12632 
        break
4910 phani.kuma 12633 
      if fid == 1:
12634 
        if ftype == TType.STRUCT:
12635 
          self.ex = TransactionServiceException()
12636 
          self.ex.read(iprot)
12637 
        else:
12638 
          iprot.skip(ftype)
12639 
      else:
12640 
        iprot.skip(ftype)
12641 
      iprot.readFieldEnd()
12642 
    iprot.readStructEnd()
12643 
 
12644 
  def write(self, oprot):
12645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12647 
      return
12648 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
12649 
    if self.ex is not None:
12650 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12651 
      self.ex.write(oprot)
12652 
      oprot.writeFieldEnd()
12653 
    oprot.writeFieldStop()
12654 
    oprot.writeStructEnd()
12655 
 
12656 
  def validate(self):
12657 
    return
12658 
 
12659 
 
12660 
  def __repr__(self):
12661 
    L = ['%s=%r' % (key, value)
12662 
      for key, value in self.__dict__.iteritems()]
12663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12664 
 
12665 
  def __eq__(self, other):
12666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12667 
 
12668 
  def __ne__(self, other):
12669 
    return not (self == other)
12670 
 
12671 
class getNonDeliveredOrdersbyCourier_args:
12672 
  """
12673 
  Attributes:
12674 
   - providerId
12675 
  """
12676 
 
12677 
  thrift_spec = (
12678 
    None, # 0
12679 
    (1, TType.I64, 'providerId', None, None, ), # 1
12680 
  )
12681 
 
12682 
  def __init__(self, providerId=None,):
12683 
    self.providerId = providerId
12684 
 
12685 
  def read(self, iprot):
12686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12688 
      return
12689 
    iprot.readStructBegin()
12690 
    while True:
12691 
      (fname, ftype, fid) = iprot.readFieldBegin()
12692 
      if ftype == TType.STOP:
12693 
        break
12694 
      if fid == 1:
12695 
        if ftype == TType.I64:
12696 
          self.providerId = iprot.readI64();
12697 
        else:
12698 
          iprot.skip(ftype)
12699 
      else:
12700 
        iprot.skip(ftype)
12701 
      iprot.readFieldEnd()
12702 
    iprot.readStructEnd()
12703 
 
12704 
  def write(self, oprot):
12705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12707 
      return
12708 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
12709 
    if self.providerId is not None:
12710 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12711 
      oprot.writeI64(self.providerId)
12712 
      oprot.writeFieldEnd()
12713 
    oprot.writeFieldStop()
12714 
    oprot.writeStructEnd()
12715 
 
12716 
  def validate(self):
12717 
    return
12718 
 
12719 
 
12720 
  def __repr__(self):
12721 
    L = ['%s=%r' % (key, value)
12722 
      for key, value in self.__dict__.iteritems()]
12723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12724 
 
12725 
  def __eq__(self, other):
12726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12727 
 
12728 
  def __ne__(self, other):
12729 
    return not (self == other)
12730 
 
12731 
class getNonDeliveredOrdersbyCourier_result:
12732 
  """
12733 
  Attributes:
12734 
   - success
12735 
  """
12736 
 
12737 
  thrift_spec = (
12738 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12739 
  )
12740 
 
12741 
  def __init__(self, success=None,):
12742 
    self.success = success
12743 
 
12744 
  def read(self, iprot):
12745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12747 
      return
12748 
    iprot.readStructBegin()
12749 
    while True:
12750 
      (fname, ftype, fid) = iprot.readFieldBegin()
12751 
      if ftype == TType.STOP:
12752 
        break
4581 phani.kuma 12753 
      if fid == 0:
12754 
        if ftype == TType.LIST:
12755 
          self.success = []
5031 varun.gupt 12756 
          (_etype270, _size267) = iprot.readListBegin()
12757 
          for _i271 in xrange(_size267):
12758 
            _elem272 = Order()
12759 
            _elem272.read(iprot)
12760 
            self.success.append(_elem272)
4581 phani.kuma 12761 
          iprot.readListEnd()
12762 
        else:
12763 
          iprot.skip(ftype)
4910 phani.kuma 12764 
      else:
12765 
        iprot.skip(ftype)
12766 
      iprot.readFieldEnd()
12767 
    iprot.readStructEnd()
12768 
 
12769 
  def write(self, oprot):
12770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12772 
      return
12773 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
12774 
    if self.success is not None:
12775 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12776 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12777 
      for iter273 in self.success:
12778 
        iter273.write(oprot)
4910 phani.kuma 12779 
      oprot.writeListEnd()
12780 
      oprot.writeFieldEnd()
12781 
    oprot.writeFieldStop()
12782 
    oprot.writeStructEnd()
12783 
 
12784 
  def validate(self):
12785 
    return
12786 
 
12787 
 
12788 
  def __repr__(self):
12789 
    L = ['%s=%r' % (key, value)
12790 
      for key, value in self.__dict__.iteritems()]
12791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12792 
 
12793 
  def __eq__(self, other):
12794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12795 
 
12796 
  def __ne__(self, other):
12797 
    return not (self == other)
12798 
 
12799 
class markOrdersAsLocalConnected_args:
12800 
  """
12801 
  Attributes:
12802 
   - providerId
12803 
   - local_connected_orders
12804 
  """
12805 
 
12806 
  thrift_spec = (
12807 
    None, # 0
12808 
    (1, TType.I64, 'providerId', None, None, ), # 1
12809 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
12810 
  )
12811 
 
12812 
  def __init__(self, providerId=None, local_connected_orders=None,):
12813 
    self.providerId = providerId
12814 
    self.local_connected_orders = local_connected_orders
12815 
 
12816 
  def read(self, iprot):
12817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12819 
      return
12820 
    iprot.readStructBegin()
12821 
    while True:
12822 
      (fname, ftype, fid) = iprot.readFieldBegin()
12823 
      if ftype == TType.STOP:
12824 
        break
12825 
      if fid == 1:
12826 
        if ftype == TType.I64:
12827 
          self.providerId = iprot.readI64();
12828 
        else:
12829 
          iprot.skip(ftype)
12830 
      elif fid == 2:
12831 
        if ftype == TType.MAP:
12832 
          self.local_connected_orders = {}
5031 varun.gupt 12833 
          (_ktype275, _vtype276, _size274 ) = iprot.readMapBegin()
12834 
          for _i278 in xrange(_size274):
12835 
            _key279 = iprot.readString();
12836 
            _val280 = iprot.readString();
12837 
            self.local_connected_orders[_key279] = _val280
4910 phani.kuma 12838 
          iprot.readMapEnd()
12839 
        else:
12840 
          iprot.skip(ftype)
12841 
      else:
12842 
        iprot.skip(ftype)
12843 
      iprot.readFieldEnd()
12844 
    iprot.readStructEnd()
12845 
 
12846 
  def write(self, oprot):
12847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12849 
      return
12850 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
12851 
    if self.providerId is not None:
12852 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12853 
      oprot.writeI64(self.providerId)
12854 
      oprot.writeFieldEnd()
12855 
    if self.local_connected_orders is not None:
12856 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
12857 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
5031 varun.gupt 12858 
      for kiter281,viter282 in self.local_connected_orders.items():
12859 
        oprot.writeString(kiter281)
12860 
        oprot.writeString(viter282)
4910 phani.kuma 12861 
      oprot.writeMapEnd()
12862 
      oprot.writeFieldEnd()
12863 
    oprot.writeFieldStop()
12864 
    oprot.writeStructEnd()
12865 
 
12866 
  def validate(self):
12867 
    return
12868 
 
12869 
 
12870 
  def __repr__(self):
12871 
    L = ['%s=%r' % (key, value)
12872 
      for key, value in self.__dict__.iteritems()]
12873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12874 
 
12875 
  def __eq__(self, other):
12876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12877 
 
12878 
  def __ne__(self, other):
12879 
    return not (self == other)
12880 
 
12881 
class markOrdersAsLocalConnected_result:
12882 
  """
12883 
  Attributes:
12884 
   - ex
12885 
  """
12886 
 
12887 
  thrift_spec = (
12888 
    None, # 0
12889 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12890 
  )
12891 
 
12892 
  def __init__(self, ex=None,):
12893 
    self.ex = ex
12894 
 
12895 
  def read(self, iprot):
12896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12898 
      return
12899 
    iprot.readStructBegin()
12900 
    while True:
12901 
      (fname, ftype, fid) = iprot.readFieldBegin()
12902 
      if ftype == TType.STOP:
12903 
        break
12904 
      if fid == 1:
3064 chandransh 12905 
        if ftype == TType.STRUCT:
12906 
          self.ex = TransactionServiceException()
12907 
          self.ex.read(iprot)
1627 ankur.sing 12908 
        else:
12909 
          iprot.skip(ftype)
12910 
      else:
12911 
        iprot.skip(ftype)
12912 
      iprot.readFieldEnd()
12913 
    iprot.readStructEnd()
12914 
 
12915 
  def write(self, oprot):
12916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12918 
      return
4910 phani.kuma 12919 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
12920 
    if self.ex is not None:
12921 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12922 
      self.ex.write(oprot)
12923 
      oprot.writeFieldEnd()
12924 
    oprot.writeFieldStop()
12925 
    oprot.writeStructEnd()
12926 
 
12927 
  def validate(self):
12928 
    return
12929 
 
12930 
 
12931 
  def __repr__(self):
12932 
    L = ['%s=%r' % (key, value)
12933 
      for key, value in self.__dict__.iteritems()]
12934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12935 
 
12936 
  def __eq__(self, other):
12937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12938 
 
12939 
  def __ne__(self, other):
12940 
    return not (self == other)
12941 
 
12942 
class getOrdersNotLocalConnected_args:
12943 
  """
12944 
  Attributes:
12945 
   - providerId
12946 
  """
12947 
 
12948 
  thrift_spec = (
12949 
    None, # 0
12950 
    (1, TType.I64, 'providerId', None, None, ), # 1
12951 
  )
12952 
 
12953 
  def __init__(self, providerId=None,):
12954 
    self.providerId = providerId
12955 
 
12956 
  def read(self, iprot):
12957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12959 
      return
12960 
    iprot.readStructBegin()
12961 
    while True:
12962 
      (fname, ftype, fid) = iprot.readFieldBegin()
12963 
      if ftype == TType.STOP:
12964 
        break
12965 
      if fid == 1:
12966 
        if ftype == TType.I64:
12967 
          self.providerId = iprot.readI64();
12968 
        else:
12969 
          iprot.skip(ftype)
12970 
      else:
12971 
        iprot.skip(ftype)
12972 
      iprot.readFieldEnd()
12973 
    iprot.readStructEnd()
12974 
 
12975 
  def write(self, oprot):
12976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12978 
      return
12979 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
12980 
    if self.providerId is not None:
12981 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12982 
      oprot.writeI64(self.providerId)
12983 
      oprot.writeFieldEnd()
12984 
    oprot.writeFieldStop()
12985 
    oprot.writeStructEnd()
12986 
 
12987 
  def validate(self):
12988 
    return
12989 
 
12990 
 
12991 
  def __repr__(self):
12992 
    L = ['%s=%r' % (key, value)
12993 
      for key, value in self.__dict__.iteritems()]
12994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12995 
 
12996 
  def __eq__(self, other):
12997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12998 
 
12999 
  def __ne__(self, other):
13000 
    return not (self == other)
13001 
 
13002 
class getOrdersNotLocalConnected_result:
13003 
  """
13004 
  Attributes:
13005 
   - success
13006 
  """
13007 
 
13008 
  thrift_spec = (
13009 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13010 
  )
13011 
 
13012 
  def __init__(self, success=None,):
13013 
    self.success = success
13014 
 
13015 
  def read(self, iprot):
13016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13018 
      return
13019 
    iprot.readStructBegin()
13020 
    while True:
13021 
      (fname, ftype, fid) = iprot.readFieldBegin()
13022 
      if ftype == TType.STOP:
13023 
        break
13024 
      if fid == 0:
13025 
        if ftype == TType.LIST:
13026 
          self.success = []
5031 varun.gupt 13027 
          (_etype286, _size283) = iprot.readListBegin()
13028 
          for _i287 in xrange(_size283):
13029 
            _elem288 = Order()
13030 
            _elem288.read(iprot)
13031 
            self.success.append(_elem288)
4910 phani.kuma 13032 
          iprot.readListEnd()
13033 
        else:
13034 
          iprot.skip(ftype)
13035 
      else:
13036 
        iprot.skip(ftype)
13037 
      iprot.readFieldEnd()
13038 
    iprot.readStructEnd()
13039 
 
13040 
  def write(self, oprot):
13041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13043 
      return
13044 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 13045 
    if self.success is not None:
13046 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13047 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13048 
      for iter289 in self.success:
13049 
        iter289.write(oprot)
4581 phani.kuma 13050 
      oprot.writeListEnd()
13051 
      oprot.writeFieldEnd()
4910 phani.kuma 13052 
    oprot.writeFieldStop()
13053 
    oprot.writeStructEnd()
13054 
 
13055 
  def validate(self):
13056 
    return
13057 
 
13058 
 
13059 
  def __repr__(self):
13060 
    L = ['%s=%r' % (key, value)
13061 
      for key, value in self.__dict__.iteritems()]
13062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13063 
 
13064 
  def __eq__(self, other):
13065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13066 
 
13067 
  def __ne__(self, other):
13068 
    return not (self == other)
13069 
 
13070 
class markOrdersAsDestinationCityReached_args:
13071 
  """
13072 
  Attributes:
13073 
   - providerId
13074 
   - destination_city_reached_orders
13075 
  """
13076 
 
13077 
  thrift_spec = (
13078 
    None, # 0
13079 
    (1, TType.I64, 'providerId', None, None, ), # 1
13080 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13081 
  )
13082 
 
13083 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
13084 
    self.providerId = providerId
13085 
    self.destination_city_reached_orders = destination_city_reached_orders
13086 
 
13087 
  def read(self, iprot):
13088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13090 
      return
13091 
    iprot.readStructBegin()
13092 
    while True:
13093 
      (fname, ftype, fid) = iprot.readFieldBegin()
13094 
      if ftype == TType.STOP:
13095 
        break
13096 
      if fid == 1:
13097 
        if ftype == TType.I64:
13098 
          self.providerId = iprot.readI64();
13099 
        else:
13100 
          iprot.skip(ftype)
13101 
      elif fid == 2:
13102 
        if ftype == TType.MAP:
13103 
          self.destination_city_reached_orders = {}
5031 varun.gupt 13104 
          (_ktype291, _vtype292, _size290 ) = iprot.readMapBegin()
13105 
          for _i294 in xrange(_size290):
13106 
            _key295 = iprot.readString();
13107 
            _val296 = iprot.readString();
13108 
            self.destination_city_reached_orders[_key295] = _val296
4910 phani.kuma 13109 
          iprot.readMapEnd()
13110 
        else:
13111 
          iprot.skip(ftype)
13112 
      else:
13113 
        iprot.skip(ftype)
13114 
      iprot.readFieldEnd()
13115 
    iprot.readStructEnd()
13116 
 
13117 
  def write(self, oprot):
13118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13120 
      return
13121 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
13122 
    if self.providerId is not None:
13123 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13124 
      oprot.writeI64(self.providerId)
13125 
      oprot.writeFieldEnd()
13126 
    if self.destination_city_reached_orders is not None:
13127 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
13128 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
5031 varun.gupt 13129 
      for kiter297,viter298 in self.destination_city_reached_orders.items():
13130 
        oprot.writeString(kiter297)
13131 
        oprot.writeString(viter298)
4910 phani.kuma 13132 
      oprot.writeMapEnd()
13133 
      oprot.writeFieldEnd()
13134 
    oprot.writeFieldStop()
13135 
    oprot.writeStructEnd()
13136 
 
13137 
  def validate(self):
13138 
    return
13139 
 
13140 
 
13141 
  def __repr__(self):
13142 
    L = ['%s=%r' % (key, value)
13143 
      for key, value in self.__dict__.iteritems()]
13144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13145 
 
13146 
  def __eq__(self, other):
13147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13148 
 
13149 
  def __ne__(self, other):
13150 
    return not (self == other)
13151 
 
13152 
class markOrdersAsDestinationCityReached_result:
13153 
  """
13154 
  Attributes:
13155 
   - ex
13156 
  """
13157 
 
13158 
  thrift_spec = (
13159 
    None, # 0
13160 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13161 
  )
13162 
 
13163 
  def __init__(self, ex=None,):
13164 
    self.ex = ex
13165 
 
13166 
  def read(self, iprot):
13167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13169 
      return
13170 
    iprot.readStructBegin()
13171 
    while True:
13172 
      (fname, ftype, fid) = iprot.readFieldBegin()
13173 
      if ftype == TType.STOP:
13174 
        break
13175 
      if fid == 1:
13176 
        if ftype == TType.STRUCT:
13177 
          self.ex = TransactionServiceException()
13178 
          self.ex.read(iprot)
13179 
        else:
13180 
          iprot.skip(ftype)
13181 
      else:
13182 
        iprot.skip(ftype)
13183 
      iprot.readFieldEnd()
13184 
    iprot.readStructEnd()
13185 
 
13186 
  def write(self, oprot):
13187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13189 
      return
13190 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 13191 
    if self.ex is not None:
3064 chandransh 13192 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13193 
      self.ex.write(oprot)
1627 ankur.sing 13194 
      oprot.writeFieldEnd()
13195 
    oprot.writeFieldStop()
13196 
    oprot.writeStructEnd()
13197 
 
3431 rajveer 13198 
  def validate(self):
13199 
    return
13200 
 
13201 
 
1627 ankur.sing 13202 
  def __repr__(self):
13203 
    L = ['%s=%r' % (key, value)
13204 
      for key, value in self.__dict__.iteritems()]
13205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13206 
 
13207 
  def __eq__(self, other):
13208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13209 
 
13210 
  def __ne__(self, other):
13211 
    return not (self == other)
13212 
 
4910 phani.kuma 13213 
class markOrdersAsFirstDeliveryAttempted_args:
13214 
  """
13215 
  Attributes:
13216 
   - providerId
13217 
   - first_atdl_orders
13218 
  """
13219 
 
13220 
  thrift_spec = (
13221 
    None, # 0
13222 
    (1, TType.I64, 'providerId', None, None, ), # 1
13223 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13224 
  )
13225 
 
13226 
  def __init__(self, providerId=None, first_atdl_orders=None,):
13227 
    self.providerId = providerId
13228 
    self.first_atdl_orders = first_atdl_orders
13229 
 
13230 
  def read(self, iprot):
13231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13233 
      return
13234 
    iprot.readStructBegin()
13235 
    while True:
13236 
      (fname, ftype, fid) = iprot.readFieldBegin()
13237 
      if ftype == TType.STOP:
13238 
        break
13239 
      if fid == 1:
13240 
        if ftype == TType.I64:
13241 
          self.providerId = iprot.readI64();
13242 
        else:
13243 
          iprot.skip(ftype)
13244 
      elif fid == 2:
13245 
        if ftype == TType.MAP:
13246 
          self.first_atdl_orders = {}
5031 varun.gupt 13247 
          (_ktype300, _vtype301, _size299 ) = iprot.readMapBegin()
13248 
          for _i303 in xrange(_size299):
13249 
            _key304 = iprot.readString();
13250 
            _val305 = iprot.readString();
13251 
            self.first_atdl_orders[_key304] = _val305
4910 phani.kuma 13252 
          iprot.readMapEnd()
13253 
        else:
13254 
          iprot.skip(ftype)
13255 
      else:
13256 
        iprot.skip(ftype)
13257 
      iprot.readFieldEnd()
13258 
    iprot.readStructEnd()
13259 
 
13260 
  def write(self, oprot):
13261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13263 
      return
13264 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
13265 
    if self.providerId is not None:
13266 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13267 
      oprot.writeI64(self.providerId)
13268 
      oprot.writeFieldEnd()
13269 
    if self.first_atdl_orders is not None:
13270 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
13271 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
5031 varun.gupt 13272 
      for kiter306,viter307 in self.first_atdl_orders.items():
13273 
        oprot.writeString(kiter306)
13274 
        oprot.writeString(viter307)
4910 phani.kuma 13275 
      oprot.writeMapEnd()
13276 
      oprot.writeFieldEnd()
13277 
    oprot.writeFieldStop()
13278 
    oprot.writeStructEnd()
13279 
 
13280 
  def validate(self):
13281 
    return
13282 
 
13283 
 
13284 
  def __repr__(self):
13285 
    L = ['%s=%r' % (key, value)
13286 
      for key, value in self.__dict__.iteritems()]
13287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13288 
 
13289 
  def __eq__(self, other):
13290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13291 
 
13292 
  def __ne__(self, other):
13293 
    return not (self == other)
13294 
 
13295 
class markOrdersAsFirstDeliveryAttempted_result:
13296 
  """
13297 
  Attributes:
13298 
   - ex
13299 
  """
13300 
 
13301 
  thrift_spec = (
13302 
    None, # 0
13303 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13304 
  )
13305 
 
13306 
  def __init__(self, ex=None,):
13307 
    self.ex = ex
13308 
 
13309 
  def read(self, iprot):
13310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13312 
      return
13313 
    iprot.readStructBegin()
13314 
    while True:
13315 
      (fname, ftype, fid) = iprot.readFieldBegin()
13316 
      if ftype == TType.STOP:
13317 
        break
13318 
      if fid == 1:
13319 
        if ftype == TType.STRUCT:
13320 
          self.ex = TransactionServiceException()
13321 
          self.ex.read(iprot)
13322 
        else:
13323 
          iprot.skip(ftype)
13324 
      else:
13325 
        iprot.skip(ftype)
13326 
      iprot.readFieldEnd()
13327 
    iprot.readStructEnd()
13328 
 
13329 
  def write(self, oprot):
13330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13332 
      return
13333 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
13334 
    if self.ex is not None:
13335 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13336 
      self.ex.write(oprot)
13337 
      oprot.writeFieldEnd()
13338 
    oprot.writeFieldStop()
13339 
    oprot.writeStructEnd()
13340 
 
13341 
  def validate(self):
13342 
    return
13343 
 
13344 
 
13345 
  def __repr__(self):
13346 
    L = ['%s=%r' % (key, value)
13347 
      for key, value in self.__dict__.iteritems()]
13348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13349 
 
13350 
  def __eq__(self, other):
13351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13352 
 
13353 
  def __ne__(self, other):
13354 
    return not (self == other)
13355 
 
3064 chandransh 13356 
class getUndeliveredOrders_args:
1886 ankur.sing 13357 
  """
13358 
  Attributes:
3064 chandransh 13359 
   - providerId
13360 
   - warehouseId
1886 ankur.sing 13361 
  """
1627 ankur.sing 13362 
 
1886 ankur.sing 13363 
  thrift_spec = (
13364 
    None, # 0
3064 chandransh 13365 
    (1, TType.I64, 'providerId', None, None, ), # 1
13366 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 13367 
  )
13368 
 
3064 chandransh 13369 
  def __init__(self, providerId=None, warehouseId=None,):
13370 
    self.providerId = providerId
13371 
    self.warehouseId = warehouseId
1886 ankur.sing 13372 
 
13373 
  def read(self, iprot):
13374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13376 
      return
13377 
    iprot.readStructBegin()
13378 
    while True:
13379 
      (fname, ftype, fid) = iprot.readFieldBegin()
13380 
      if ftype == TType.STOP:
13381 
        break
13382 
      if fid == 1:
13383 
        if ftype == TType.I64:
3064 chandransh 13384 
          self.providerId = iprot.readI64();
1886 ankur.sing 13385 
        else:
13386 
          iprot.skip(ftype)
3064 chandransh 13387 
      elif fid == 2:
13388 
        if ftype == TType.I64:
13389 
          self.warehouseId = iprot.readI64();
13390 
        else:
13391 
          iprot.skip(ftype)
1886 ankur.sing 13392 
      else:
13393 
        iprot.skip(ftype)
13394 
      iprot.readFieldEnd()
13395 
    iprot.readStructEnd()
13396 
 
13397 
  def write(self, oprot):
13398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13400 
      return
3064 chandransh 13401 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 13402 
    if self.providerId is not None:
3064 chandransh 13403 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13404 
      oprot.writeI64(self.providerId)
1886 ankur.sing 13405 
      oprot.writeFieldEnd()
3431 rajveer 13406 
    if self.warehouseId is not None:
3064 chandransh 13407 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13408 
      oprot.writeI64(self.warehouseId)
13409 
      oprot.writeFieldEnd()
1886 ankur.sing 13410 
    oprot.writeFieldStop()
13411 
    oprot.writeStructEnd()
13412 
 
3431 rajveer 13413 
  def validate(self):
13414 
    return
13415 
 
13416 
 
1886 ankur.sing 13417 
  def __repr__(self):
13418 
    L = ['%s=%r' % (key, value)
13419 
      for key, value in self.__dict__.iteritems()]
13420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13421 
 
13422 
  def __eq__(self, other):
13423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13424 
 
13425 
  def __ne__(self, other):
13426 
    return not (self == other)
13427 
 
3064 chandransh 13428 
class getUndeliveredOrders_result:
1886 ankur.sing 13429 
  """
13430 
  Attributes:
13431 
   - success
13432 
  """
13433 
 
13434 
  thrift_spec = (
13435 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13436 
  )
13437 
 
13438 
  def __init__(self, success=None,):
13439 
    self.success = success
13440 
 
13441 
  def read(self, iprot):
13442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13444 
      return
13445 
    iprot.readStructBegin()
13446 
    while True:
13447 
      (fname, ftype, fid) = iprot.readFieldBegin()
13448 
      if ftype == TType.STOP:
13449 
        break
13450 
      if fid == 0:
13451 
        if ftype == TType.LIST:
13452 
          self.success = []
5031 varun.gupt 13453 
          (_etype311, _size308) = iprot.readListBegin()
13454 
          for _i312 in xrange(_size308):
13455 
            _elem313 = Order()
13456 
            _elem313.read(iprot)
13457 
            self.success.append(_elem313)
1886 ankur.sing 13458 
          iprot.readListEnd()
13459 
        else:
13460 
          iprot.skip(ftype)
13461 
      else:
13462 
        iprot.skip(ftype)
13463 
      iprot.readFieldEnd()
13464 
    iprot.readStructEnd()
13465 
 
13466 
  def write(self, oprot):
13467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13469 
      return
3064 chandransh 13470 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 13471 
    if self.success is not None:
1886 ankur.sing 13472 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13473 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13474 
      for iter314 in self.success:
13475 
        iter314.write(oprot)
1886 ankur.sing 13476 
      oprot.writeListEnd()
13477 
      oprot.writeFieldEnd()
13478 
    oprot.writeFieldStop()
13479 
    oprot.writeStructEnd()
13480 
 
3431 rajveer 13481 
  def validate(self):
13482 
    return
13483 
 
13484 
 
1886 ankur.sing 13485 
  def __repr__(self):
13486 
    L = ['%s=%r' % (key, value)
13487 
      for key, value in self.__dict__.iteritems()]
13488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13489 
 
13490 
  def __eq__(self, other):
13491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13492 
 
13493 
  def __ne__(self, other):
13494 
    return not (self == other)
13495 
 
4783 phani.kuma 13496 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
13497 
 
13498 
  thrift_spec = (
13499 
  )
13500 
 
13501 
  def read(self, iprot):
13502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13504 
      return
13505 
    iprot.readStructBegin()
13506 
    while True:
13507 
      (fname, ftype, fid) = iprot.readFieldBegin()
13508 
      if ftype == TType.STOP:
13509 
        break
13510 
      else:
13511 
        iprot.skip(ftype)
13512 
      iprot.readFieldEnd()
13513 
    iprot.readStructEnd()
13514 
 
13515 
  def write(self, oprot):
13516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13518 
      return
13519 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
13520 
    oprot.writeFieldStop()
13521 
    oprot.writeStructEnd()
13522 
 
13523 
  def validate(self):
13524 
    return
13525 
 
13526 
 
13527 
  def __repr__(self):
13528 
    L = ['%s=%r' % (key, value)
13529 
      for key, value in self.__dict__.iteritems()]
13530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13531 
 
13532 
  def __eq__(self, other):
13533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13534 
 
13535 
  def __ne__(self, other):
13536 
    return not (self == other)
13537 
 
13538 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
13539 
  """
13540 
  Attributes:
13541 
   - success
13542 
  """
13543 
 
13544 
  thrift_spec = (
13545 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13546 
  )
13547 
 
13548 
  def __init__(self, success=None,):
13549 
    self.success = success
13550 
 
13551 
  def read(self, iprot):
13552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13554 
      return
13555 
    iprot.readStructBegin()
13556 
    while True:
13557 
      (fname, ftype, fid) = iprot.readFieldBegin()
13558 
      if ftype == TType.STOP:
13559 
        break
13560 
      if fid == 0:
13561 
        if ftype == TType.LIST:
13562 
          self.success = []
5031 varun.gupt 13563 
          (_etype318, _size315) = iprot.readListBegin()
13564 
          for _i319 in xrange(_size315):
13565 
            _elem320 = Order()
13566 
            _elem320.read(iprot)
13567 
            self.success.append(_elem320)
4783 phani.kuma 13568 
          iprot.readListEnd()
13569 
        else:
13570 
          iprot.skip(ftype)
13571 
      else:
13572 
        iprot.skip(ftype)
13573 
      iprot.readFieldEnd()
13574 
    iprot.readStructEnd()
13575 
 
13576 
  def write(self, oprot):
13577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13579 
      return
13580 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
13581 
    if self.success is not None:
13582 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13583 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13584 
      for iter321 in self.success:
13585 
        iter321.write(oprot)
4783 phani.kuma 13586 
      oprot.writeListEnd()
13587 
      oprot.writeFieldEnd()
13588 
    oprot.writeFieldStop()
13589 
    oprot.writeStructEnd()
13590 
 
13591 
  def validate(self):
13592 
    return
13593 
 
13594 
 
13595 
  def __repr__(self):
13596 
    L = ['%s=%r' % (key, value)
13597 
      for key, value in self.__dict__.iteritems()]
13598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13599 
 
13600 
  def __eq__(self, other):
13601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13602 
 
13603 
  def __ne__(self, other):
13604 
    return not (self == other)
13605 
 
2536 chandransh 13606 
class toggleDOAFlag_args:
13607 
  """
13608 
  Attributes:
13609 
   - orderId
13610 
  """
1886 ankur.sing 13611 
 
2536 chandransh 13612 
  thrift_spec = (
13613 
    None, # 0
13614 
    (1, TType.I64, 'orderId', None, None, ), # 1
13615 
  )
13616 
 
13617 
  def __init__(self, orderId=None,):
13618 
    self.orderId = orderId
13619 
 
13620 
  def read(self, iprot):
13621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13623 
      return
13624 
    iprot.readStructBegin()
13625 
    while True:
13626 
      (fname, ftype, fid) = iprot.readFieldBegin()
13627 
      if ftype == TType.STOP:
13628 
        break
13629 
      if fid == 1:
13630 
        if ftype == TType.I64:
13631 
          self.orderId = iprot.readI64();
13632 
        else:
13633 
          iprot.skip(ftype)
13634 
      else:
13635 
        iprot.skip(ftype)
13636 
      iprot.readFieldEnd()
13637 
    iprot.readStructEnd()
13638 
 
13639 
  def write(self, oprot):
13640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13642 
      return
13643 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 13644 
    if self.orderId is not None:
2536 chandransh 13645 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13646 
      oprot.writeI64(self.orderId)
13647 
      oprot.writeFieldEnd()
13648 
    oprot.writeFieldStop()
13649 
    oprot.writeStructEnd()
13650 
 
3431 rajveer 13651 
  def validate(self):
13652 
    return
13653 
 
13654 
 
2536 chandransh 13655 
  def __repr__(self):
13656 
    L = ['%s=%r' % (key, value)
13657 
      for key, value in self.__dict__.iteritems()]
13658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13659 
 
13660 
  def __eq__(self, other):
13661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13662 
 
13663 
  def __ne__(self, other):
13664 
    return not (self == other)
13665 
 
13666 
class toggleDOAFlag_result:
13667 
  """
13668 
  Attributes:
13669 
   - success
13670 
   - ex
13671 
  """
13672 
 
13673 
  thrift_spec = (
13674 
    (0, TType.BOOL, 'success', None, None, ), # 0
13675 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13676 
  )
13677 
 
13678 
  def __init__(self, success=None, ex=None,):
13679 
    self.success = success
13680 
    self.ex = ex
13681 
 
13682 
  def read(self, iprot):
13683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13685 
      return
13686 
    iprot.readStructBegin()
13687 
    while True:
13688 
      (fname, ftype, fid) = iprot.readFieldBegin()
13689 
      if ftype == TType.STOP:
13690 
        break
13691 
      if fid == 0:
13692 
        if ftype == TType.BOOL:
13693 
          self.success = iprot.readBool();
13694 
        else:
13695 
          iprot.skip(ftype)
13696 
      elif fid == 1:
13697 
        if ftype == TType.STRUCT:
13698 
          self.ex = TransactionServiceException()
13699 
          self.ex.read(iprot)
13700 
        else:
13701 
          iprot.skip(ftype)
13702 
      else:
13703 
        iprot.skip(ftype)
13704 
      iprot.readFieldEnd()
13705 
    iprot.readStructEnd()
13706 
 
13707 
  def write(self, oprot):
13708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13710 
      return
13711 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 13712 
    if self.success is not None:
2536 chandransh 13713 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13714 
      oprot.writeBool(self.success)
13715 
      oprot.writeFieldEnd()
3431 rajveer 13716 
    if self.ex is not None:
2536 chandransh 13717 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13718 
      self.ex.write(oprot)
13719 
      oprot.writeFieldEnd()
13720 
    oprot.writeFieldStop()
13721 
    oprot.writeStructEnd()
13722 
 
3431 rajveer 13723 
  def validate(self):
13724 
    return
13725 
 
13726 
 
2536 chandransh 13727 
  def __repr__(self):
13728 
    L = ['%s=%r' % (key, value)
13729 
      for key, value in self.__dict__.iteritems()]
13730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13731 
 
13732 
  def __eq__(self, other):
13733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13734 
 
13735 
  def __ne__(self, other):
13736 
    return not (self == other)
13737 
 
4712 rajveer 13738 
class markOrderAsDelivered_args:
13739 
  """
13740 
  Attributes:
13741 
   - orderId
13742 
   - deliveryTimestamp
13743 
   - receiver
13744 
  """
13745 
 
13746 
  thrift_spec = None
13747 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
13748 
    self.orderId = orderId
13749 
    self.deliveryTimestamp = deliveryTimestamp
13750 
    self.receiver = receiver
13751 
 
13752 
  def read(self, iprot):
13753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13755 
      return
13756 
    iprot.readStructBegin()
13757 
    while True:
13758 
      (fname, ftype, fid) = iprot.readFieldBegin()
13759 
      if ftype == TType.STOP:
13760 
        break
13761 
      if fid == 1:
13762 
        if ftype == TType.I64:
13763 
          self.orderId = iprot.readI64();
13764 
        else:
13765 
          iprot.skip(ftype)
13766 
      elif fid == 2:
13767 
        if ftype == TType.I64:
13768 
          self.deliveryTimestamp = iprot.readI64();
13769 
        else:
13770 
          iprot.skip(ftype)
13771 
      elif fid == -1:
13772 
        if ftype == TType.STRING:
13773 
          self.receiver = iprot.readString();
13774 
        else:
13775 
          iprot.skip(ftype)
13776 
      else:
13777 
        iprot.skip(ftype)
13778 
      iprot.readFieldEnd()
13779 
    iprot.readStructEnd()
13780 
 
13781 
  def write(self, oprot):
13782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13784 
      return
13785 
    oprot.writeStructBegin('markOrderAsDelivered_args')
13786 
    if self.receiver is not None:
13787 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
13788 
      oprot.writeString(self.receiver)
13789 
      oprot.writeFieldEnd()
13790 
    if self.orderId is not None:
13791 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13792 
      oprot.writeI64(self.orderId)
13793 
      oprot.writeFieldEnd()
13794 
    if self.deliveryTimestamp is not None:
13795 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
13796 
      oprot.writeI64(self.deliveryTimestamp)
13797 
      oprot.writeFieldEnd()
13798 
    oprot.writeFieldStop()
13799 
    oprot.writeStructEnd()
13800 
 
13801 
  def validate(self):
13802 
    return
13803 
 
13804 
 
13805 
  def __repr__(self):
13806 
    L = ['%s=%r' % (key, value)
13807 
      for key, value in self.__dict__.iteritems()]
13808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13809 
 
13810 
  def __eq__(self, other):
13811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13812 
 
13813 
  def __ne__(self, other):
13814 
    return not (self == other)
13815 
 
13816 
class markOrderAsDelivered_result:
13817 
  """
13818 
  Attributes:
13819 
   - ex
13820 
  """
13821 
 
13822 
  thrift_spec = (
13823 
    None, # 0
13824 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13825 
  )
13826 
 
13827 
  def __init__(self, ex=None,):
13828 
    self.ex = ex
13829 
 
13830 
  def read(self, iprot):
13831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13833 
      return
13834 
    iprot.readStructBegin()
13835 
    while True:
13836 
      (fname, ftype, fid) = iprot.readFieldBegin()
13837 
      if ftype == TType.STOP:
13838 
        break
13839 
      if fid == 1:
13840 
        if ftype == TType.STRUCT:
13841 
          self.ex = TransactionServiceException()
13842 
          self.ex.read(iprot)
13843 
        else:
13844 
          iprot.skip(ftype)
13845 
      else:
13846 
        iprot.skip(ftype)
13847 
      iprot.readFieldEnd()
13848 
    iprot.readStructEnd()
13849 
 
13850 
  def write(self, oprot):
13851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13853 
      return
13854 
    oprot.writeStructBegin('markOrderAsDelivered_result')
13855 
    if self.ex is not None:
13856 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13857 
      self.ex.write(oprot)
13858 
      oprot.writeFieldEnd()
13859 
    oprot.writeFieldStop()
13860 
    oprot.writeStructEnd()
13861 
 
13862 
  def validate(self):
13863 
    return
13864 
 
13865 
 
13866 
  def __repr__(self):
13867 
    L = ['%s=%r' % (key, value)
13868 
      for key, value in self.__dict__.iteritems()]
13869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13870 
 
13871 
  def __eq__(self, other):
13872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13873 
 
13874 
  def __ne__(self, other):
13875 
    return not (self == other)
13876 
 
4454 rajveer 13877 
class markOrderDoaRequestReceived_args:
13878 
  """
13879 
  Attributes:
13880 
   - orderId
13881 
  """
13882 
 
13883 
  thrift_spec = (
13884 
    None, # 0
13885 
    (1, TType.I64, 'orderId', None, None, ), # 1
13886 
  )
13887 
 
13888 
  def __init__(self, orderId=None,):
13889 
    self.orderId = orderId
13890 
 
13891 
  def read(self, iprot):
13892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13894 
      return
13895 
    iprot.readStructBegin()
13896 
    while True:
13897 
      (fname, ftype, fid) = iprot.readFieldBegin()
13898 
      if ftype == TType.STOP:
13899 
        break
13900 
      if fid == 1:
13901 
        if ftype == TType.I64:
13902 
          self.orderId = iprot.readI64();
13903 
        else:
13904 
          iprot.skip(ftype)
13905 
      else:
13906 
        iprot.skip(ftype)
13907 
      iprot.readFieldEnd()
13908 
    iprot.readStructEnd()
13909 
 
13910 
  def write(self, oprot):
13911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13913 
      return
13914 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
13915 
    if self.orderId is not None:
13916 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13917 
      oprot.writeI64(self.orderId)
13918 
      oprot.writeFieldEnd()
13919 
    oprot.writeFieldStop()
13920 
    oprot.writeStructEnd()
13921 
 
13922 
  def validate(self):
13923 
    return
13924 
 
13925 
 
13926 
  def __repr__(self):
13927 
    L = ['%s=%r' % (key, value)
13928 
      for key, value in self.__dict__.iteritems()]
13929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13930 
 
13931 
  def __eq__(self, other):
13932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13933 
 
13934 
  def __ne__(self, other):
13935 
    return not (self == other)
13936 
 
13937 
class markOrderDoaRequestReceived_result:
13938 
  """
13939 
  Attributes:
13940 
   - success
13941 
   - ex
13942 
  """
13943 
 
13944 
  thrift_spec = (
13945 
    (0, TType.BOOL, 'success', None, None, ), # 0
13946 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13947 
  )
13948 
 
13949 
  def __init__(self, success=None, ex=None,):
13950 
    self.success = success
13951 
    self.ex = ex
13952 
 
13953 
  def read(self, iprot):
13954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13956 
      return
13957 
    iprot.readStructBegin()
13958 
    while True:
13959 
      (fname, ftype, fid) = iprot.readFieldBegin()
13960 
      if ftype == TType.STOP:
13961 
        break
13962 
      if fid == 0:
13963 
        if ftype == TType.BOOL:
13964 
          self.success = iprot.readBool();
13965 
        else:
13966 
          iprot.skip(ftype)
13967 
      elif fid == 1:
13968 
        if ftype == TType.STRUCT:
13969 
          self.ex = TransactionServiceException()
13970 
          self.ex.read(iprot)
13971 
        else:
13972 
          iprot.skip(ftype)
13973 
      else:
13974 
        iprot.skip(ftype)
13975 
      iprot.readFieldEnd()
13976 
    iprot.readStructEnd()
13977 
 
13978 
  def write(self, oprot):
13979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13981 
      return
13982 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
13983 
    if self.success is not None:
13984 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13985 
      oprot.writeBool(self.success)
13986 
      oprot.writeFieldEnd()
13987 
    if self.ex is not None:
13988 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13989 
      self.ex.write(oprot)
13990 
      oprot.writeFieldEnd()
13991 
    oprot.writeFieldStop()
13992 
    oprot.writeStructEnd()
13993 
 
13994 
  def validate(self):
13995 
    return
13996 
 
13997 
 
13998 
  def __repr__(self):
13999 
    L = ['%s=%r' % (key, value)
14000 
      for key, value in self.__dict__.iteritems()]
14001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14002 
 
14003 
  def __eq__(self, other):
14004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14005 
 
14006 
  def __ne__(self, other):
14007 
    return not (self == other)
14008 
 
14009 
class markOrderDoaRequestAuthorized_args:
14010 
  """
14011 
  Attributes:
14012 
   - orderId
14013 
   - isAuthorized
14014 
  """
14015 
 
14016 
  thrift_spec = (
14017 
    None, # 0
14018 
    (1, TType.I64, 'orderId', None, None, ), # 1
14019 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14020 
  )
14021 
 
14022 
  def __init__(self, orderId=None, isAuthorized=None,):
14023 
    self.orderId = orderId
14024 
    self.isAuthorized = isAuthorized
14025 
 
14026 
  def read(self, iprot):
14027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14029 
      return
14030 
    iprot.readStructBegin()
14031 
    while True:
14032 
      (fname, ftype, fid) = iprot.readFieldBegin()
14033 
      if ftype == TType.STOP:
14034 
        break
14035 
      if fid == 1:
14036 
        if ftype == TType.I64:
14037 
          self.orderId = iprot.readI64();
14038 
        else:
14039 
          iprot.skip(ftype)
14040 
      elif fid == 2:
14041 
        if ftype == TType.BOOL:
14042 
          self.isAuthorized = iprot.readBool();
14043 
        else:
14044 
          iprot.skip(ftype)
14045 
      else:
14046 
        iprot.skip(ftype)
14047 
      iprot.readFieldEnd()
14048 
    iprot.readStructEnd()
14049 
 
14050 
  def write(self, oprot):
14051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14053 
      return
14054 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
14055 
    if self.orderId is not None:
14056 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14057 
      oprot.writeI64(self.orderId)
14058 
      oprot.writeFieldEnd()
14059 
    if self.isAuthorized is not None:
14060 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14061 
      oprot.writeBool(self.isAuthorized)
14062 
      oprot.writeFieldEnd()
14063 
    oprot.writeFieldStop()
14064 
    oprot.writeStructEnd()
14065 
 
14066 
  def validate(self):
14067 
    return
14068 
 
14069 
 
14070 
  def __repr__(self):
14071 
    L = ['%s=%r' % (key, value)
14072 
      for key, value in self.__dict__.iteritems()]
14073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14074 
 
14075 
  def __eq__(self, other):
14076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14077 
 
14078 
  def __ne__(self, other):
14079 
    return not (self == other)
14080 
 
14081 
class markOrderDoaRequestAuthorized_result:
14082 
  """
14083 
  Attributes:
14084 
   - success
14085 
   - ex
14086 
  """
14087 
 
14088 
  thrift_spec = (
14089 
    (0, TType.BOOL, 'success', None, None, ), # 0
14090 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14091 
  )
14092 
 
14093 
  def __init__(self, success=None, ex=None,):
14094 
    self.success = success
14095 
    self.ex = ex
14096 
 
14097 
  def read(self, iprot):
14098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14100 
      return
14101 
    iprot.readStructBegin()
14102 
    while True:
14103 
      (fname, ftype, fid) = iprot.readFieldBegin()
14104 
      if ftype == TType.STOP:
14105 
        break
14106 
      if fid == 0:
14107 
        if ftype == TType.BOOL:
14108 
          self.success = iprot.readBool();
14109 
        else:
14110 
          iprot.skip(ftype)
14111 
      elif fid == 1:
14112 
        if ftype == TType.STRUCT:
14113 
          self.ex = TransactionServiceException()
14114 
          self.ex.read(iprot)
14115 
        else:
14116 
          iprot.skip(ftype)
14117 
      else:
14118 
        iprot.skip(ftype)
14119 
      iprot.readFieldEnd()
14120 
    iprot.readStructEnd()
14121 
 
14122 
  def write(self, oprot):
14123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14125 
      return
14126 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
14127 
    if self.success is not None:
14128 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14129 
      oprot.writeBool(self.success)
14130 
      oprot.writeFieldEnd()
14131 
    if self.ex is not None:
14132 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14133 
      self.ex.write(oprot)
14134 
      oprot.writeFieldEnd()
14135 
    oprot.writeFieldStop()
14136 
    oprot.writeStructEnd()
14137 
 
14138 
  def validate(self):
14139 
    return
14140 
 
14141 
 
14142 
  def __repr__(self):
14143 
    L = ['%s=%r' % (key, value)
14144 
      for key, value in self.__dict__.iteritems()]
14145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14146 
 
14147 
  def __eq__(self, other):
14148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14149 
 
14150 
  def __ne__(self, other):
14151 
    return not (self == other)
14152 
 
4488 rajveer 14153 
class markOrderReturnRequestReceived_args:
14154 
  """
14155 
  Attributes:
14156 
   - orderId
14157 
  """
14158 
 
14159 
  thrift_spec = (
14160 
    None, # 0
14161 
    (1, TType.I64, 'orderId', None, None, ), # 1
14162 
  )
14163 
 
14164 
  def __init__(self, orderId=None,):
14165 
    self.orderId = orderId
14166 
 
14167 
  def read(self, iprot):
14168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14170 
      return
14171 
    iprot.readStructBegin()
14172 
    while True:
14173 
      (fname, ftype, fid) = iprot.readFieldBegin()
14174 
      if ftype == TType.STOP:
14175 
        break
14176 
      if fid == 1:
14177 
        if ftype == TType.I64:
14178 
          self.orderId = iprot.readI64();
14179 
        else:
14180 
          iprot.skip(ftype)
14181 
      else:
14182 
        iprot.skip(ftype)
14183 
      iprot.readFieldEnd()
14184 
    iprot.readStructEnd()
14185 
 
14186 
  def write(self, oprot):
14187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14189 
      return
14190 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
14191 
    if self.orderId is not None:
14192 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14193 
      oprot.writeI64(self.orderId)
14194 
      oprot.writeFieldEnd()
14195 
    oprot.writeFieldStop()
14196 
    oprot.writeStructEnd()
14197 
 
14198 
  def validate(self):
14199 
    return
14200 
 
14201 
 
14202 
  def __repr__(self):
14203 
    L = ['%s=%r' % (key, value)
14204 
      for key, value in self.__dict__.iteritems()]
14205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14206 
 
14207 
  def __eq__(self, other):
14208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14209 
 
14210 
  def __ne__(self, other):
14211 
    return not (self == other)
14212 
 
14213 
class markOrderReturnRequestReceived_result:
14214 
  """
14215 
  Attributes:
14216 
   - success
14217 
   - ex
14218 
  """
14219 
 
14220 
  thrift_spec = (
14221 
    (0, TType.BOOL, 'success', None, None, ), # 0
14222 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14223 
  )
14224 
 
14225 
  def __init__(self, success=None, ex=None,):
14226 
    self.success = success
14227 
    self.ex = ex
14228 
 
14229 
  def read(self, iprot):
14230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14232 
      return
14233 
    iprot.readStructBegin()
14234 
    while True:
14235 
      (fname, ftype, fid) = iprot.readFieldBegin()
14236 
      if ftype == TType.STOP:
14237 
        break
14238 
      if fid == 0:
14239 
        if ftype == TType.BOOL:
14240 
          self.success = iprot.readBool();
14241 
        else:
14242 
          iprot.skip(ftype)
14243 
      elif fid == 1:
14244 
        if ftype == TType.STRUCT:
14245 
          self.ex = TransactionServiceException()
14246 
          self.ex.read(iprot)
14247 
        else:
14248 
          iprot.skip(ftype)
14249 
      else:
14250 
        iprot.skip(ftype)
14251 
      iprot.readFieldEnd()
14252 
    iprot.readStructEnd()
14253 
 
14254 
  def write(self, oprot):
14255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14257 
      return
14258 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
14259 
    if self.success is not None:
14260 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14261 
      oprot.writeBool(self.success)
14262 
      oprot.writeFieldEnd()
14263 
    if self.ex is not None:
14264 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14265 
      self.ex.write(oprot)
14266 
      oprot.writeFieldEnd()
14267 
    oprot.writeFieldStop()
14268 
    oprot.writeStructEnd()
14269 
 
14270 
  def validate(self):
14271 
    return
14272 
 
14273 
 
14274 
  def __repr__(self):
14275 
    L = ['%s=%r' % (key, value)
14276 
      for key, value in self.__dict__.iteritems()]
14277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14278 
 
14279 
  def __eq__(self, other):
14280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14281 
 
14282 
  def __ne__(self, other):
14283 
    return not (self == other)
14284 
 
14285 
class markOrderReturnRequestAuthorized_args:
14286 
  """
14287 
  Attributes:
14288 
   - orderId
14289 
   - isAuthorized
14290 
  """
14291 
 
14292 
  thrift_spec = (
14293 
    None, # 0
14294 
    (1, TType.I64, 'orderId', None, None, ), # 1
14295 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14296 
  )
14297 
 
14298 
  def __init__(self, orderId=None, isAuthorized=None,):
14299 
    self.orderId = orderId
14300 
    self.isAuthorized = isAuthorized
14301 
 
14302 
  def read(self, iprot):
14303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14305 
      return
14306 
    iprot.readStructBegin()
14307 
    while True:
14308 
      (fname, ftype, fid) = iprot.readFieldBegin()
14309 
      if ftype == TType.STOP:
14310 
        break
14311 
      if fid == 1:
14312 
        if ftype == TType.I64:
14313 
          self.orderId = iprot.readI64();
14314 
        else:
14315 
          iprot.skip(ftype)
14316 
      elif fid == 2:
14317 
        if ftype == TType.BOOL:
14318 
          self.isAuthorized = iprot.readBool();
14319 
        else:
14320 
          iprot.skip(ftype)
14321 
      else:
14322 
        iprot.skip(ftype)
14323 
      iprot.readFieldEnd()
14324 
    iprot.readStructEnd()
14325 
 
14326 
  def write(self, oprot):
14327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14329 
      return
14330 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
14331 
    if self.orderId is not None:
14332 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14333 
      oprot.writeI64(self.orderId)
14334 
      oprot.writeFieldEnd()
14335 
    if self.isAuthorized is not None:
14336 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14337 
      oprot.writeBool(self.isAuthorized)
14338 
      oprot.writeFieldEnd()
14339 
    oprot.writeFieldStop()
14340 
    oprot.writeStructEnd()
14341 
 
14342 
  def validate(self):
14343 
    return
14344 
 
14345 
 
14346 
  def __repr__(self):
14347 
    L = ['%s=%r' % (key, value)
14348 
      for key, value in self.__dict__.iteritems()]
14349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14350 
 
14351 
  def __eq__(self, other):
14352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14353 
 
14354 
  def __ne__(self, other):
14355 
    return not (self == other)
14356 
 
14357 
class markOrderReturnRequestAuthorized_result:
14358 
  """
14359 
  Attributes:
14360 
   - success
14361 
   - ex
14362 
  """
14363 
 
14364 
  thrift_spec = (
14365 
    (0, TType.BOOL, 'success', None, None, ), # 0
14366 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14367 
  )
14368 
 
14369 
  def __init__(self, success=None, ex=None,):
14370 
    self.success = success
14371 
    self.ex = ex
14372 
 
14373 
  def read(self, iprot):
14374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14376 
      return
14377 
    iprot.readStructBegin()
14378 
    while True:
14379 
      (fname, ftype, fid) = iprot.readFieldBegin()
14380 
      if ftype == TType.STOP:
14381 
        break
14382 
      if fid == 0:
14383 
        if ftype == TType.BOOL:
14384 
          self.success = iprot.readBool();
14385 
        else:
14386 
          iprot.skip(ftype)
14387 
      elif fid == 1:
14388 
        if ftype == TType.STRUCT:
14389 
          self.ex = TransactionServiceException()
14390 
          self.ex.read(iprot)
14391 
        else:
14392 
          iprot.skip(ftype)
14393 
      else:
14394 
        iprot.skip(ftype)
14395 
      iprot.readFieldEnd()
14396 
    iprot.readStructEnd()
14397 
 
14398 
  def write(self, oprot):
14399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14401 
      return
14402 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
14403 
    if self.success is not None:
14404 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14405 
      oprot.writeBool(self.success)
14406 
      oprot.writeFieldEnd()
14407 
    if self.ex is not None:
14408 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14409 
      self.ex.write(oprot)
14410 
      oprot.writeFieldEnd()
14411 
    oprot.writeFieldStop()
14412 
    oprot.writeStructEnd()
14413 
 
14414 
  def validate(self):
14415 
    return
14416 
 
14417 
 
14418 
  def __repr__(self):
14419 
    L = ['%s=%r' % (key, value)
14420 
      for key, value in self.__dict__.iteritems()]
14421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14422 
 
14423 
  def __eq__(self, other):
14424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14425 
 
14426 
  def __ne__(self, other):
14427 
    return not (self == other)
14428 
 
2536 chandransh 14429 
class requestPickupNumber_args:
14430 
  """
14431 
  Attributes:
14432 
   - orderId
4579 rajveer 14433 
   - providerId
2536 chandransh 14434 
  """
14435 
 
14436 
  thrift_spec = (
14437 
    None, # 0
14438 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 14439 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 14440 
  )
14441 
 
4579 rajveer 14442 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 14443 
    self.orderId = orderId
4579 rajveer 14444 
    self.providerId = providerId
2536 chandransh 14445 
 
14446 
  def read(self, iprot):
14447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14449 
      return
14450 
    iprot.readStructBegin()
14451 
    while True:
14452 
      (fname, ftype, fid) = iprot.readFieldBegin()
14453 
      if ftype == TType.STOP:
14454 
        break
14455 
      if fid == 1:
14456 
        if ftype == TType.I64:
14457 
          self.orderId = iprot.readI64();
14458 
        else:
14459 
          iprot.skip(ftype)
4579 rajveer 14460 
      elif fid == 2:
14461 
        if ftype == TType.I64:
14462 
          self.providerId = iprot.readI64();
14463 
        else:
14464 
          iprot.skip(ftype)
2536 chandransh 14465 
      else:
14466 
        iprot.skip(ftype)
14467 
      iprot.readFieldEnd()
14468 
    iprot.readStructEnd()
14469 
 
14470 
  def write(self, oprot):
14471 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14472 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14473 
      return
14474 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 14475 
    if self.orderId is not None:
2536 chandransh 14476 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14477 
      oprot.writeI64(self.orderId)
14478 
      oprot.writeFieldEnd()
4579 rajveer 14479 
    if self.providerId is not None:
14480 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
14481 
      oprot.writeI64(self.providerId)
14482 
      oprot.writeFieldEnd()
2536 chandransh 14483 
    oprot.writeFieldStop()
14484 
    oprot.writeStructEnd()
14485 
 
3431 rajveer 14486 
  def validate(self):
14487 
    return
14488 
 
14489 
 
2536 chandransh 14490 
  def __repr__(self):
14491 
    L = ['%s=%r' % (key, value)
14492 
      for key, value in self.__dict__.iteritems()]
14493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14494 
 
14495 
  def __eq__(self, other):
14496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14497 
 
14498 
  def __ne__(self, other):
14499 
    return not (self == other)
14500 
 
14501 
class requestPickupNumber_result:
14502 
  """
14503 
  Attributes:
14504 
   - success
14505 
   - ex
14506 
  """
14507 
 
14508 
  thrift_spec = (
14509 
    (0, TType.BOOL, 'success', None, None, ), # 0
14510 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14511 
  )
14512 
 
14513 
  def __init__(self, success=None, ex=None,):
14514 
    self.success = success
14515 
    self.ex = ex
14516 
 
14517 
  def read(self, iprot):
14518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14520 
      return
14521 
    iprot.readStructBegin()
14522 
    while True:
14523 
      (fname, ftype, fid) = iprot.readFieldBegin()
14524 
      if ftype == TType.STOP:
14525 
        break
14526 
      if fid == 0:
14527 
        if ftype == TType.BOOL:
14528 
          self.success = iprot.readBool();
14529 
        else:
14530 
          iprot.skip(ftype)
14531 
      elif fid == 1:
14532 
        if ftype == TType.STRUCT:
14533 
          self.ex = TransactionServiceException()
14534 
          self.ex.read(iprot)
14535 
        else:
14536 
          iprot.skip(ftype)
14537 
      else:
14538 
        iprot.skip(ftype)
14539 
      iprot.readFieldEnd()
14540 
    iprot.readStructEnd()
14541 
 
14542 
  def write(self, oprot):
14543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14545 
      return
14546 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 14547 
    if self.success is not None:
2536 chandransh 14548 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14549 
      oprot.writeBool(self.success)
14550 
      oprot.writeFieldEnd()
3431 rajveer 14551 
    if self.ex is not None:
2536 chandransh 14552 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14553 
      self.ex.write(oprot)
14554 
      oprot.writeFieldEnd()
14555 
    oprot.writeFieldStop()
14556 
    oprot.writeStructEnd()
14557 
 
3431 rajveer 14558 
  def validate(self):
14559 
    return
14560 
 
14561 
 
2536 chandransh 14562 
  def __repr__(self):
14563 
    L = ['%s=%r' % (key, value)
14564 
      for key, value in self.__dict__.iteritems()]
14565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14566 
 
14567 
  def __eq__(self, other):
14568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14569 
 
14570 
  def __ne__(self, other):
14571 
    return not (self == other)
14572 
 
14573 
class authorizePickup_args:
14574 
  """
14575 
  Attributes:
14576 
   - orderId
14577 
   - pickupNumber
4602 rajveer 14578 
   - providerId
2536 chandransh 14579 
  """
14580 
 
14581 
  thrift_spec = (
14582 
    None, # 0
14583 
    (1, TType.I64, 'orderId', None, None, ), # 1
14584 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 14585 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 14586 
  )
14587 
 
4602 rajveer 14588 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 14589 
    self.orderId = orderId
14590 
    self.pickupNumber = pickupNumber
4602 rajveer 14591 
    self.providerId = providerId
2536 chandransh 14592 
 
14593 
  def read(self, iprot):
14594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14596 
      return
14597 
    iprot.readStructBegin()
14598 
    while True:
14599 
      (fname, ftype, fid) = iprot.readFieldBegin()
14600 
      if ftype == TType.STOP:
14601 
        break
14602 
      if fid == 1:
14603 
        if ftype == TType.I64:
14604 
          self.orderId = iprot.readI64();
14605 
        else:
14606 
          iprot.skip(ftype)
14607 
      elif fid == 2:
14608 
        if ftype == TType.STRING:
14609 
          self.pickupNumber = iprot.readString();
14610 
        else:
14611 
          iprot.skip(ftype)
4602 rajveer 14612 
      elif fid == 3:
14613 
        if ftype == TType.I64:
14614 
          self.providerId = iprot.readI64();
14615 
        else:
14616 
          iprot.skip(ftype)
2536 chandransh 14617 
      else:
14618 
        iprot.skip(ftype)
14619 
      iprot.readFieldEnd()
14620 
    iprot.readStructEnd()
14621 
 
14622 
  def write(self, oprot):
14623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14625 
      return
14626 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 14627 
    if self.orderId is not None:
2536 chandransh 14628 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14629 
      oprot.writeI64(self.orderId)
14630 
      oprot.writeFieldEnd()
3431 rajveer 14631 
    if self.pickupNumber is not None:
2536 chandransh 14632 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
14633 
      oprot.writeString(self.pickupNumber)
14634 
      oprot.writeFieldEnd()
4602 rajveer 14635 
    if self.providerId is not None:
14636 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
14637 
      oprot.writeI64(self.providerId)
14638 
      oprot.writeFieldEnd()
2536 chandransh 14639 
    oprot.writeFieldStop()
14640 
    oprot.writeStructEnd()
14641 
 
3431 rajveer 14642 
  def validate(self):
14643 
    return
14644 
 
14645 
 
2536 chandransh 14646 
  def __repr__(self):
14647 
    L = ['%s=%r' % (key, value)
14648 
      for key, value in self.__dict__.iteritems()]
14649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14650 
 
14651 
  def __eq__(self, other):
14652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14653 
 
14654 
  def __ne__(self, other):
14655 
    return not (self == other)
14656 
 
14657 
class authorizePickup_result:
14658 
  """
14659 
  Attributes:
14660 
   - success
14661 
   - ex
14662 
  """
14663 
 
14664 
  thrift_spec = (
14665 
    (0, TType.BOOL, 'success', None, None, ), # 0
14666 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14667 
  )
14668 
 
14669 
  def __init__(self, success=None, ex=None,):
14670 
    self.success = success
14671 
    self.ex = ex
14672 
 
14673 
  def read(self, iprot):
14674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14676 
      return
14677 
    iprot.readStructBegin()
14678 
    while True:
14679 
      (fname, ftype, fid) = iprot.readFieldBegin()
14680 
      if ftype == TType.STOP:
14681 
        break
14682 
      if fid == 0:
14683 
        if ftype == TType.BOOL:
14684 
          self.success = iprot.readBool();
14685 
        else:
14686 
          iprot.skip(ftype)
14687 
      elif fid == 1:
14688 
        if ftype == TType.STRUCT:
14689 
          self.ex = TransactionServiceException()
14690 
          self.ex.read(iprot)
14691 
        else:
14692 
          iprot.skip(ftype)
14693 
      else:
14694 
        iprot.skip(ftype)
14695 
      iprot.readFieldEnd()
14696 
    iprot.readStructEnd()
14697 
 
14698 
  def write(self, oprot):
14699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14701 
      return
14702 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 14703 
    if self.success is not None:
2536 chandransh 14704 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14705 
      oprot.writeBool(self.success)
14706 
      oprot.writeFieldEnd()
3431 rajveer 14707 
    if self.ex is not None:
2536 chandransh 14708 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14709 
      self.ex.write(oprot)
14710 
      oprot.writeFieldEnd()
14711 
    oprot.writeFieldStop()
14712 
    oprot.writeStructEnd()
14713 
 
3431 rajveer 14714 
  def validate(self):
14715 
    return
14716 
 
14717 
 
2536 chandransh 14718 
  def __repr__(self):
14719 
    L = ['%s=%r' % (key, value)
14720 
      for key, value in self.__dict__.iteritems()]
14721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14722 
 
14723 
  def __eq__(self, other):
14724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14725 
 
14726 
  def __ne__(self, other):
14727 
    return not (self == other)
14728 
 
2764 chandransh 14729 
class markDoasAsPickedUp_args:
14730 
  """
14731 
  Attributes:
14732 
   - providerId
14733 
   - pickupDetails
14734 
  """
14735 
 
14736 
  thrift_spec = (
14737 
    None, # 0
14738 
    (1, TType.I64, 'providerId', None, None, ), # 1
14739 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
14740 
  )
14741 
 
14742 
  def __init__(self, providerId=None, pickupDetails=None,):
14743 
    self.providerId = providerId
14744 
    self.pickupDetails = pickupDetails
14745 
 
14746 
  def read(self, iprot):
14747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14749 
      return
14750 
    iprot.readStructBegin()
14751 
    while True:
14752 
      (fname, ftype, fid) = iprot.readFieldBegin()
14753 
      if ftype == TType.STOP:
14754 
        break
14755 
      if fid == 1:
14756 
        if ftype == TType.I64:
14757 
          self.providerId = iprot.readI64();
14758 
        else:
14759 
          iprot.skip(ftype)
14760 
      elif fid == 2:
14761 
        if ftype == TType.MAP:
14762 
          self.pickupDetails = {}
5031 varun.gupt 14763 
          (_ktype323, _vtype324, _size322 ) = iprot.readMapBegin()
14764 
          for _i326 in xrange(_size322):
14765 
            _key327 = iprot.readString();
14766 
            _val328 = iprot.readString();
14767 
            self.pickupDetails[_key327] = _val328
2764 chandransh 14768 
          iprot.readMapEnd()
14769 
        else:
14770 
          iprot.skip(ftype)
14771 
      else:
14772 
        iprot.skip(ftype)
14773 
      iprot.readFieldEnd()
14774 
    iprot.readStructEnd()
14775 
 
14776 
  def write(self, oprot):
14777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14779 
      return
14780 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 14781 
    if self.providerId is not None:
2764 chandransh 14782 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14783 
      oprot.writeI64(self.providerId)
14784 
      oprot.writeFieldEnd()
3431 rajveer 14785 
    if self.pickupDetails is not None:
2764 chandransh 14786 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14787 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 14788 
      for kiter329,viter330 in self.pickupDetails.items():
14789 
        oprot.writeString(kiter329)
14790 
        oprot.writeString(viter330)
2764 chandransh 14791 
      oprot.writeMapEnd()
14792 
      oprot.writeFieldEnd()
14793 
    oprot.writeFieldStop()
14794 
    oprot.writeStructEnd()
14795 
 
3431 rajveer 14796 
  def validate(self):
14797 
    return
14798 
 
14799 
 
2764 chandransh 14800 
  def __repr__(self):
14801 
    L = ['%s=%r' % (key, value)
14802 
      for key, value in self.__dict__.iteritems()]
14803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14804 
 
14805 
  def __eq__(self, other):
14806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14807 
 
14808 
  def __ne__(self, other):
14809 
    return not (self == other)
14810 
 
14811 
class markDoasAsPickedUp_result:
4910 phani.kuma 14812 
 
14813 
  thrift_spec = (
14814 
  )
14815 
 
14816 
  def read(self, iprot):
14817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14819 
      return
14820 
    iprot.readStructBegin()
14821 
    while True:
14822 
      (fname, ftype, fid) = iprot.readFieldBegin()
14823 
      if ftype == TType.STOP:
14824 
        break
14825 
      else:
14826 
        iprot.skip(ftype)
14827 
      iprot.readFieldEnd()
14828 
    iprot.readStructEnd()
14829 
 
14830 
  def write(self, oprot):
14831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14833 
      return
14834 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
14835 
    oprot.writeFieldStop()
14836 
    oprot.writeStructEnd()
14837 
 
14838 
  def validate(self):
14839 
    return
14840 
 
14841 
 
14842 
  def __repr__(self):
14843 
    L = ['%s=%r' % (key, value)
14844 
      for key, value in self.__dict__.iteritems()]
14845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14846 
 
14847 
  def __eq__(self, other):
14848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14849 
 
14850 
  def __ne__(self, other):
14851 
    return not (self == other)
14852 
 
14853 
class getDoasNotPickedUp_args:
2764 chandransh 14854 
  """
14855 
  Attributes:
4910 phani.kuma 14856 
   - providerId
14857 
  """
14858 
 
14859 
  thrift_spec = (
14860 
    None, # 0
14861 
    (1, TType.I64, 'providerId', None, None, ), # 1
14862 
  )
14863 
 
14864 
  def __init__(self, providerId=None,):
14865 
    self.providerId = providerId
14866 
 
14867 
  def read(self, iprot):
14868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14870 
      return
14871 
    iprot.readStructBegin()
14872 
    while True:
14873 
      (fname, ftype, fid) = iprot.readFieldBegin()
14874 
      if ftype == TType.STOP:
14875 
        break
14876 
      if fid == 1:
14877 
        if ftype == TType.I64:
14878 
          self.providerId = iprot.readI64();
14879 
        else:
14880 
          iprot.skip(ftype)
14881 
      else:
14882 
        iprot.skip(ftype)
14883 
      iprot.readFieldEnd()
14884 
    iprot.readStructEnd()
14885 
 
14886 
  def write(self, oprot):
14887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14889 
      return
14890 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
14891 
    if self.providerId is not None:
14892 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14893 
      oprot.writeI64(self.providerId)
14894 
      oprot.writeFieldEnd()
14895 
    oprot.writeFieldStop()
14896 
    oprot.writeStructEnd()
14897 
 
14898 
  def validate(self):
14899 
    return
14900 
 
14901 
 
14902 
  def __repr__(self):
14903 
    L = ['%s=%r' % (key, value)
14904 
      for key, value in self.__dict__.iteritems()]
14905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14906 
 
14907 
  def __eq__(self, other):
14908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14909 
 
14910 
  def __ne__(self, other):
14911 
    return not (self == other)
14912 
 
14913 
class getDoasNotPickedUp_result:
14914 
  """
14915 
  Attributes:
2764 chandransh 14916 
   - success
14917 
  """
14918 
 
14919 
  thrift_spec = (
14920 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14921 
  )
14922 
 
14923 
  def __init__(self, success=None,):
14924 
    self.success = success
14925 
 
14926 
  def read(self, iprot):
14927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14929 
      return
14930 
    iprot.readStructBegin()
14931 
    while True:
14932 
      (fname, ftype, fid) = iprot.readFieldBegin()
14933 
      if ftype == TType.STOP:
14934 
        break
14935 
      if fid == 0:
14936 
        if ftype == TType.LIST:
14937 
          self.success = []
5031 varun.gupt 14938 
          (_etype334, _size331) = iprot.readListBegin()
14939 
          for _i335 in xrange(_size331):
14940 
            _elem336 = Order()
14941 
            _elem336.read(iprot)
14942 
            self.success.append(_elem336)
2764 chandransh 14943 
          iprot.readListEnd()
14944 
        else:
14945 
          iprot.skip(ftype)
14946 
      else:
14947 
        iprot.skip(ftype)
14948 
      iprot.readFieldEnd()
14949 
    iprot.readStructEnd()
14950 
 
14951 
  def write(self, oprot):
14952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14954 
      return
4910 phani.kuma 14955 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 14956 
    if self.success is not None:
2764 chandransh 14957 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14958 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 14959 
      for iter337 in self.success:
14960 
        iter337.write(oprot)
2764 chandransh 14961 
      oprot.writeListEnd()
14962 
      oprot.writeFieldEnd()
14963 
    oprot.writeFieldStop()
14964 
    oprot.writeStructEnd()
14965 
 
3431 rajveer 14966 
  def validate(self):
14967 
    return
14968 
 
14969 
 
2764 chandransh 14970 
  def __repr__(self):
14971 
    L = ['%s=%r' % (key, value)
14972 
      for key, value in self.__dict__.iteritems()]
14973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14974 
 
14975 
  def __eq__(self, other):
14976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14977 
 
14978 
  def __ne__(self, other):
14979 
    return not (self == other)
14980 
 
4741 phani.kuma 14981 
class markReturnOrdersAsPickedUp_args:
14982 
  """
14983 
  Attributes:
14984 
   - providerId
14985 
   - pickupDetails
14986 
  """
14987 
 
14988 
  thrift_spec = (
14989 
    None, # 0
14990 
    (1, TType.I64, 'providerId', None, None, ), # 1
14991 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
14992 
  )
14993 
 
14994 
  def __init__(self, providerId=None, pickupDetails=None,):
14995 
    self.providerId = providerId
14996 
    self.pickupDetails = pickupDetails
14997 
 
14998 
  def read(self, iprot):
14999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15001 
      return
15002 
    iprot.readStructBegin()
15003 
    while True:
15004 
      (fname, ftype, fid) = iprot.readFieldBegin()
15005 
      if ftype == TType.STOP:
15006 
        break
15007 
      if fid == 1:
15008 
        if ftype == TType.I64:
15009 
          self.providerId = iprot.readI64();
15010 
        else:
15011 
          iprot.skip(ftype)
15012 
      elif fid == 2:
15013 
        if ftype == TType.MAP:
15014 
          self.pickupDetails = {}
5031 varun.gupt 15015 
          (_ktype339, _vtype340, _size338 ) = iprot.readMapBegin()
15016 
          for _i342 in xrange(_size338):
15017 
            _key343 = iprot.readString();
15018 
            _val344 = iprot.readString();
15019 
            self.pickupDetails[_key343] = _val344
4741 phani.kuma 15020 
          iprot.readMapEnd()
15021 
        else:
15022 
          iprot.skip(ftype)
15023 
      else:
15024 
        iprot.skip(ftype)
15025 
      iprot.readFieldEnd()
15026 
    iprot.readStructEnd()
15027 
 
15028 
  def write(self, oprot):
15029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15031 
      return
15032 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
15033 
    if self.providerId is not None:
15034 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15035 
      oprot.writeI64(self.providerId)
15036 
      oprot.writeFieldEnd()
15037 
    if self.pickupDetails is not None:
15038 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15039 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 15040 
      for kiter345,viter346 in self.pickupDetails.items():
15041 
        oprot.writeString(kiter345)
15042 
        oprot.writeString(viter346)
4741 phani.kuma 15043 
      oprot.writeMapEnd()
15044 
      oprot.writeFieldEnd()
15045 
    oprot.writeFieldStop()
15046 
    oprot.writeStructEnd()
15047 
 
15048 
  def validate(self):
15049 
    return
15050 
 
15051 
 
15052 
  def __repr__(self):
15053 
    L = ['%s=%r' % (key, value)
15054 
      for key, value in self.__dict__.iteritems()]
15055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15056 
 
15057 
  def __eq__(self, other):
15058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15059 
 
15060 
  def __ne__(self, other):
15061 
    return not (self == other)
15062 
 
15063 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 15064 
 
15065 
  thrift_spec = (
15066 
  )
15067 
 
15068 
  def read(self, iprot):
15069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15071 
      return
15072 
    iprot.readStructBegin()
15073 
    while True:
15074 
      (fname, ftype, fid) = iprot.readFieldBegin()
15075 
      if ftype == TType.STOP:
15076 
        break
15077 
      else:
15078 
        iprot.skip(ftype)
15079 
      iprot.readFieldEnd()
15080 
    iprot.readStructEnd()
15081 
 
15082 
  def write(self, oprot):
15083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15085 
      return
15086 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
15087 
    oprot.writeFieldStop()
15088 
    oprot.writeStructEnd()
15089 
 
15090 
  def validate(self):
15091 
    return
15092 
 
15093 
 
15094 
  def __repr__(self):
15095 
    L = ['%s=%r' % (key, value)
15096 
      for key, value in self.__dict__.iteritems()]
15097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15098 
 
15099 
  def __eq__(self, other):
15100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15101 
 
15102 
  def __ne__(self, other):
15103 
    return not (self == other)
15104 
 
15105 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 15106 
  """
15107 
  Attributes:
4910 phani.kuma 15108 
   - providerId
15109 
  """
15110 
 
15111 
  thrift_spec = (
15112 
    None, # 0
15113 
    (1, TType.I64, 'providerId', None, None, ), # 1
15114 
  )
15115 
 
15116 
  def __init__(self, providerId=None,):
15117 
    self.providerId = providerId
15118 
 
15119 
  def read(self, iprot):
15120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15122 
      return
15123 
    iprot.readStructBegin()
15124 
    while True:
15125 
      (fname, ftype, fid) = iprot.readFieldBegin()
15126 
      if ftype == TType.STOP:
15127 
        break
15128 
      if fid == 1:
15129 
        if ftype == TType.I64:
15130 
          self.providerId = iprot.readI64();
15131 
        else:
15132 
          iprot.skip(ftype)
15133 
      else:
15134 
        iprot.skip(ftype)
15135 
      iprot.readFieldEnd()
15136 
    iprot.readStructEnd()
15137 
 
15138 
  def write(self, oprot):
15139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15141 
      return
15142 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
15143 
    if self.providerId is not None:
15144 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15145 
      oprot.writeI64(self.providerId)
15146 
      oprot.writeFieldEnd()
15147 
    oprot.writeFieldStop()
15148 
    oprot.writeStructEnd()
15149 
 
15150 
  def validate(self):
15151 
    return
15152 
 
15153 
 
15154 
  def __repr__(self):
15155 
    L = ['%s=%r' % (key, value)
15156 
      for key, value in self.__dict__.iteritems()]
15157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15158 
 
15159 
  def __eq__(self, other):
15160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15161 
 
15162 
  def __ne__(self, other):
15163 
    return not (self == other)
15164 
 
15165 
class getReturnOrdersNotPickedUp_result:
15166 
  """
15167 
  Attributes:
4741 phani.kuma 15168 
   - success
15169 
  """
15170 
 
15171 
  thrift_spec = (
15172 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15173 
  )
15174 
 
15175 
  def __init__(self, success=None,):
15176 
    self.success = success
15177 
 
15178 
  def read(self, iprot):
15179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15181 
      return
15182 
    iprot.readStructBegin()
15183 
    while True:
15184 
      (fname, ftype, fid) = iprot.readFieldBegin()
15185 
      if ftype == TType.STOP:
15186 
        break
15187 
      if fid == 0:
15188 
        if ftype == TType.LIST:
15189 
          self.success = []
5031 varun.gupt 15190 
          (_etype350, _size347) = iprot.readListBegin()
15191 
          for _i351 in xrange(_size347):
15192 
            _elem352 = Order()
15193 
            _elem352.read(iprot)
15194 
            self.success.append(_elem352)
4741 phani.kuma 15195 
          iprot.readListEnd()
15196 
        else:
15197 
          iprot.skip(ftype)
15198 
      else:
15199 
        iprot.skip(ftype)
15200 
      iprot.readFieldEnd()
15201 
    iprot.readStructEnd()
15202 
 
15203 
  def write(self, oprot):
15204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15206 
      return
4910 phani.kuma 15207 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 15208 
    if self.success is not None:
15209 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15210 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 15211 
      for iter353 in self.success:
15212 
        iter353.write(oprot)
4741 phani.kuma 15213 
      oprot.writeListEnd()
15214 
      oprot.writeFieldEnd()
15215 
    oprot.writeFieldStop()
15216 
    oprot.writeStructEnd()
15217 
 
15218 
  def validate(self):
15219 
    return
15220 
 
15221 
 
15222 
  def __repr__(self):
15223 
    L = ['%s=%r' % (key, value)
15224 
      for key, value in self.__dict__.iteritems()]
15225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15226 
 
15227 
  def __eq__(self, other):
15228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15229 
 
15230 
  def __ne__(self, other):
15231 
    return not (self == other)
15232 
 
2616 chandransh 15233 
class receiveReturn_args:
2591 chandransh 15234 
  """
15235 
  Attributes:
15236 
   - orderId
4479 rajveer 15237 
   - receiveCondition
2591 chandransh 15238 
  """
2536 chandransh 15239 
 
2591 chandransh 15240 
  thrift_spec = (
15241 
    None, # 0
15242 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 15243 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 15244 
  )
15245 
 
4479 rajveer 15246 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 15247 
    self.orderId = orderId
4479 rajveer 15248 
    self.receiveCondition = receiveCondition
2591 chandransh 15249 
 
15250 
  def read(self, iprot):
15251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15253 
      return
15254 
    iprot.readStructBegin()
15255 
    while True:
15256 
      (fname, ftype, fid) = iprot.readFieldBegin()
15257 
      if ftype == TType.STOP:
15258 
        break
15259 
      if fid == 1:
15260 
        if ftype == TType.I64:
15261 
          self.orderId = iprot.readI64();
15262 
        else:
15263 
          iprot.skip(ftype)
4479 rajveer 15264 
      elif fid == 2:
15265 
        if ftype == TType.I64:
15266 
          self.receiveCondition = iprot.readI64();
15267 
        else:
15268 
          iprot.skip(ftype)
2591 chandransh 15269 
      else:
15270 
        iprot.skip(ftype)
15271 
      iprot.readFieldEnd()
15272 
    iprot.readStructEnd()
15273 
 
15274 
  def write(self, oprot):
15275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15277 
      return
2616 chandransh 15278 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 15279 
    if self.orderId is not None:
2591 chandransh 15280 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15281 
      oprot.writeI64(self.orderId)
15282 
      oprot.writeFieldEnd()
4479 rajveer 15283 
    if self.receiveCondition is not None:
15284 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
15285 
      oprot.writeI64(self.receiveCondition)
15286 
      oprot.writeFieldEnd()
2591 chandransh 15287 
    oprot.writeFieldStop()
15288 
    oprot.writeStructEnd()
15289 
 
3431 rajveer 15290 
  def validate(self):
15291 
    return
15292 
 
15293 
 
2591 chandransh 15294 
  def __repr__(self):
15295 
    L = ['%s=%r' % (key, value)
15296 
      for key, value in self.__dict__.iteritems()]
15297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15298 
 
15299 
  def __eq__(self, other):
15300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15301 
 
15302 
  def __ne__(self, other):
15303 
    return not (self == other)
15304 
 
2616 chandransh 15305 
class receiveReturn_result:
2591 chandransh 15306 
  """
15307 
  Attributes:
15308 
   - success
15309 
   - ex
15310 
  """
15311 
 
15312 
  thrift_spec = (
15313 
    (0, TType.BOOL, 'success', None, None, ), # 0
15314 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15315 
  )
15316 
 
15317 
  def __init__(self, success=None, ex=None,):
15318 
    self.success = success
15319 
    self.ex = ex
15320 
 
15321 
  def read(self, iprot):
15322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15324 
      return
15325 
    iprot.readStructBegin()
15326 
    while True:
15327 
      (fname, ftype, fid) = iprot.readFieldBegin()
15328 
      if ftype == TType.STOP:
15329 
        break
15330 
      if fid == 0:
15331 
        if ftype == TType.BOOL:
15332 
          self.success = iprot.readBool();
15333 
        else:
15334 
          iprot.skip(ftype)
15335 
      elif fid == 1:
15336 
        if ftype == TType.STRUCT:
15337 
          self.ex = TransactionServiceException()
15338 
          self.ex.read(iprot)
15339 
        else:
15340 
          iprot.skip(ftype)
15341 
      else:
15342 
        iprot.skip(ftype)
15343 
      iprot.readFieldEnd()
15344 
    iprot.readStructEnd()
15345 
 
15346 
  def write(self, oprot):
15347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15349 
      return
2616 chandransh 15350 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 15351 
    if self.success is not None:
2591 chandransh 15352 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15353 
      oprot.writeBool(self.success)
15354 
      oprot.writeFieldEnd()
3431 rajveer 15355 
    if self.ex is not None:
2591 chandransh 15356 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15357 
      self.ex.write(oprot)
15358 
      oprot.writeFieldEnd()
15359 
    oprot.writeFieldStop()
15360 
    oprot.writeStructEnd()
15361 
 
3431 rajveer 15362 
  def validate(self):
15363 
    return
15364 
 
15365 
 
2591 chandransh 15366 
  def __repr__(self):
15367 
    L = ['%s=%r' % (key, value)
15368 
      for key, value in self.__dict__.iteritems()]
15369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15370 
 
15371 
  def __eq__(self, other):
15372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15373 
 
15374 
  def __ne__(self, other):
15375 
    return not (self == other)
15376 
 
15377 
class validateDoa_args:
15378 
  """
15379 
  Attributes:
15380 
   - orderId
15381 
   - isValid
15382 
  """
15383 
 
15384 
  thrift_spec = (
15385 
    None, # 0
15386 
    (1, TType.I64, 'orderId', None, None, ), # 1
15387 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
15388 
  )
15389 
 
15390 
  def __init__(self, orderId=None, isValid=None,):
15391 
    self.orderId = orderId
15392 
    self.isValid = isValid
15393 
 
15394 
  def read(self, iprot):
15395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15397 
      return
15398 
    iprot.readStructBegin()
15399 
    while True:
15400 
      (fname, ftype, fid) = iprot.readFieldBegin()
15401 
      if ftype == TType.STOP:
15402 
        break
15403 
      if fid == 1:
15404 
        if ftype == TType.I64:
15405 
          self.orderId = iprot.readI64();
15406 
        else:
15407 
          iprot.skip(ftype)
15408 
      elif fid == 2:
15409 
        if ftype == TType.BOOL:
15410 
          self.isValid = iprot.readBool();
15411 
        else:
15412 
          iprot.skip(ftype)
15413 
      else:
15414 
        iprot.skip(ftype)
15415 
      iprot.readFieldEnd()
15416 
    iprot.readStructEnd()
15417 
 
15418 
  def write(self, oprot):
15419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15421 
      return
15422 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 15423 
    if self.orderId is not None:
2591 chandransh 15424 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15425 
      oprot.writeI64(self.orderId)
15426 
      oprot.writeFieldEnd()
3431 rajveer 15427 
    if self.isValid is not None:
2591 chandransh 15428 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
15429 
      oprot.writeBool(self.isValid)
15430 
      oprot.writeFieldEnd()
15431 
    oprot.writeFieldStop()
15432 
    oprot.writeStructEnd()
15433 
 
3431 rajveer 15434 
  def validate(self):
15435 
    return
15436 
 
15437 
 
2591 chandransh 15438 
  def __repr__(self):
15439 
    L = ['%s=%r' % (key, value)
15440 
      for key, value in self.__dict__.iteritems()]
15441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15442 
 
15443 
  def __eq__(self, other):
15444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15445 
 
15446 
  def __ne__(self, other):
15447 
    return not (self == other)
15448 
 
15449 
class validateDoa_result:
15450 
  """
15451 
  Attributes:
15452 
   - success
15453 
   - ex
15454 
  """
15455 
 
15456 
  thrift_spec = (
15457 
    (0, TType.BOOL, 'success', None, None, ), # 0
15458 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15459 
  )
15460 
 
15461 
  def __init__(self, success=None, ex=None,):
15462 
    self.success = success
15463 
    self.ex = ex
15464 
 
15465 
  def read(self, iprot):
15466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15468 
      return
15469 
    iprot.readStructBegin()
15470 
    while True:
15471 
      (fname, ftype, fid) = iprot.readFieldBegin()
15472 
      if ftype == TType.STOP:
15473 
        break
15474 
      if fid == 0:
15475 
        if ftype == TType.BOOL:
15476 
          self.success = iprot.readBool();
15477 
        else:
15478 
          iprot.skip(ftype)
15479 
      elif fid == 1:
15480 
        if ftype == TType.STRUCT:
15481 
          self.ex = TransactionServiceException()
15482 
          self.ex.read(iprot)
15483 
        else:
15484 
          iprot.skip(ftype)
15485 
      else:
15486 
        iprot.skip(ftype)
15487 
      iprot.readFieldEnd()
15488 
    iprot.readStructEnd()
15489 
 
15490 
  def write(self, oprot):
15491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15493 
      return
15494 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 15495 
    if self.success is not None:
2591 chandransh 15496 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15497 
      oprot.writeBool(self.success)
15498 
      oprot.writeFieldEnd()
3431 rajveer 15499 
    if self.ex is not None:
2591 chandransh 15500 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15501 
      self.ex.write(oprot)
15502 
      oprot.writeFieldEnd()
15503 
    oprot.writeFieldStop()
15504 
    oprot.writeStructEnd()
15505 
 
3431 rajveer 15506 
  def validate(self):
15507 
    return
15508 
 
15509 
 
2591 chandransh 15510 
  def __repr__(self):
15511 
    L = ['%s=%r' % (key, value)
15512 
      for key, value in self.__dict__.iteritems()]
15513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15514 
 
15515 
  def __eq__(self, other):
15516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15517 
 
15518 
  def __ne__(self, other):
15519 
    return not (self == other)
15520 
 
4495 rajveer 15521 
class validateReturnProduct_args:
15522 
  """
15523 
  Attributes:
15524 
   - orderId
15525 
   - isUsable
15526 
  """
15527 
 
15528 
  thrift_spec = (
15529 
    None, # 0
15530 
    (1, TType.I64, 'orderId', None, None, ), # 1
15531 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
15532 
  )
15533 
 
15534 
  def __init__(self, orderId=None, isUsable=None,):
15535 
    self.orderId = orderId
15536 
    self.isUsable = isUsable
15537 
 
15538 
  def read(self, iprot):
15539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15541 
      return
15542 
    iprot.readStructBegin()
15543 
    while True:
15544 
      (fname, ftype, fid) = iprot.readFieldBegin()
15545 
      if ftype == TType.STOP:
15546 
        break
15547 
      if fid == 1:
15548 
        if ftype == TType.I64:
15549 
          self.orderId = iprot.readI64();
15550 
        else:
15551 
          iprot.skip(ftype)
15552 
      elif fid == 2:
15553 
        if ftype == TType.BOOL:
15554 
          self.isUsable = iprot.readBool();
15555 
        else:
15556 
          iprot.skip(ftype)
15557 
      else:
15558 
        iprot.skip(ftype)
15559 
      iprot.readFieldEnd()
15560 
    iprot.readStructEnd()
15561 
 
15562 
  def write(self, oprot):
15563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15565 
      return
15566 
    oprot.writeStructBegin('validateReturnProduct_args')
15567 
    if self.orderId is not None:
15568 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15569 
      oprot.writeI64(self.orderId)
15570 
      oprot.writeFieldEnd()
15571 
    if self.isUsable is not None:
15572 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
15573 
      oprot.writeBool(self.isUsable)
15574 
      oprot.writeFieldEnd()
15575 
    oprot.writeFieldStop()
15576 
    oprot.writeStructEnd()
15577 
 
15578 
  def validate(self):
15579 
    return
15580 
 
15581 
 
15582 
  def __repr__(self):
15583 
    L = ['%s=%r' % (key, value)
15584 
      for key, value in self.__dict__.iteritems()]
15585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15586 
 
15587 
  def __eq__(self, other):
15588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15589 
 
15590 
  def __ne__(self, other):
15591 
    return not (self == other)
15592 
 
15593 
class validateReturnProduct_result:
15594 
  """
15595 
  Attributes:
15596 
   - success
15597 
   - ex
15598 
  """
15599 
 
15600 
  thrift_spec = (
15601 
    (0, TType.BOOL, 'success', None, None, ), # 0
15602 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15603 
  )
15604 
 
15605 
  def __init__(self, success=None, ex=None,):
15606 
    self.success = success
15607 
    self.ex = ex
15608 
 
15609 
  def read(self, iprot):
15610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15612 
      return
15613 
    iprot.readStructBegin()
15614 
    while True:
15615 
      (fname, ftype, fid) = iprot.readFieldBegin()
15616 
      if ftype == TType.STOP:
15617 
        break
15618 
      if fid == 0:
15619 
        if ftype == TType.BOOL:
15620 
          self.success = iprot.readBool();
15621 
        else:
15622 
          iprot.skip(ftype)
15623 
      elif fid == 1:
15624 
        if ftype == TType.STRUCT:
15625 
          self.ex = TransactionServiceException()
15626 
          self.ex.read(iprot)
15627 
        else:
15628 
          iprot.skip(ftype)
15629 
      else:
15630 
        iprot.skip(ftype)
15631 
      iprot.readFieldEnd()
15632 
    iprot.readStructEnd()
15633 
 
15634 
  def write(self, oprot):
15635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15637 
      return
15638 
    oprot.writeStructBegin('validateReturnProduct_result')
15639 
    if self.success is not None:
15640 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15641 
      oprot.writeBool(self.success)
15642 
      oprot.writeFieldEnd()
15643 
    if self.ex is not None:
15644 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15645 
      self.ex.write(oprot)
15646 
      oprot.writeFieldEnd()
15647 
    oprot.writeFieldStop()
15648 
    oprot.writeStructEnd()
15649 
 
15650 
  def validate(self):
15651 
    return
15652 
 
15653 
 
15654 
  def __repr__(self):
15655 
    L = ['%s=%r' % (key, value)
15656 
      for key, value in self.__dict__.iteritems()]
15657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15658 
 
15659 
  def __eq__(self, other):
15660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15661 
 
15662 
  def __ne__(self, other):
15663 
    return not (self == other)
15664 
 
2616 chandransh 15665 
class reshipOrder_args:
15666 
  """
15667 
  Attributes:
15668 
   - orderId
15669 
  """
2591 chandransh 15670 
 
2616 chandransh 15671 
  thrift_spec = (
15672 
    None, # 0
15673 
    (1, TType.I64, 'orderId', None, None, ), # 1
15674 
  )
15675 
 
15676 
  def __init__(self, orderId=None,):
15677 
    self.orderId = orderId
15678 
 
15679 
  def read(self, iprot):
15680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15682 
      return
15683 
    iprot.readStructBegin()
15684 
    while True:
15685 
      (fname, ftype, fid) = iprot.readFieldBegin()
15686 
      if ftype == TType.STOP:
15687 
        break
15688 
      if fid == 1:
15689 
        if ftype == TType.I64:
15690 
          self.orderId = iprot.readI64();
15691 
        else:
15692 
          iprot.skip(ftype)
15693 
      else:
15694 
        iprot.skip(ftype)
15695 
      iprot.readFieldEnd()
15696 
    iprot.readStructEnd()
15697 
 
15698 
  def write(self, oprot):
15699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15701 
      return
15702 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 15703 
    if self.orderId is not None:
2616 chandransh 15704 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15705 
      oprot.writeI64(self.orderId)
15706 
      oprot.writeFieldEnd()
15707 
    oprot.writeFieldStop()
15708 
    oprot.writeStructEnd()
15709 
 
3431 rajveer 15710 
  def validate(self):
15711 
    return
15712 
 
15713 
 
2616 chandransh 15714 
  def __repr__(self):
15715 
    L = ['%s=%r' % (key, value)
15716 
      for key, value in self.__dict__.iteritems()]
15717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15718 
 
15719 
  def __eq__(self, other):
15720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15721 
 
15722 
  def __ne__(self, other):
15723 
    return not (self == other)
15724 
 
15725 
class reshipOrder_result:
15726 
  """
15727 
  Attributes:
15728 
   - success
15729 
   - ex
15730 
  """
15731 
 
15732 
  thrift_spec = (
15733 
    (0, TType.I64, 'success', None, None, ), # 0
15734 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15735 
  )
15736 
 
15737 
  def __init__(self, success=None, ex=None,):
15738 
    self.success = success
15739 
    self.ex = ex
15740 
 
15741 
  def read(self, iprot):
15742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15744 
      return
15745 
    iprot.readStructBegin()
15746 
    while True:
15747 
      (fname, ftype, fid) = iprot.readFieldBegin()
15748 
      if ftype == TType.STOP:
15749 
        break
15750 
      if fid == 0:
15751 
        if ftype == TType.I64:
15752 
          self.success = iprot.readI64();
15753 
        else:
15754 
          iprot.skip(ftype)
15755 
      elif fid == 1:
15756 
        if ftype == TType.STRUCT:
15757 
          self.ex = TransactionServiceException()
15758 
          self.ex.read(iprot)
15759 
        else:
15760 
          iprot.skip(ftype)
15761 
      else:
15762 
        iprot.skip(ftype)
15763 
      iprot.readFieldEnd()
15764 
    iprot.readStructEnd()
15765 
 
15766 
  def write(self, oprot):
15767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15769 
      return
15770 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 15771 
    if self.success is not None:
2616 chandransh 15772 
      oprot.writeFieldBegin('success', TType.I64, 0)
15773 
      oprot.writeI64(self.success)
15774 
      oprot.writeFieldEnd()
3431 rajveer 15775 
    if self.ex is not None:
2616 chandransh 15776 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15777 
      self.ex.write(oprot)
15778 
      oprot.writeFieldEnd()
15779 
    oprot.writeFieldStop()
15780 
    oprot.writeStructEnd()
15781 
 
3431 rajveer 15782 
  def validate(self):
15783 
    return
15784 
 
15785 
 
2616 chandransh 15786 
  def __repr__(self):
15787 
    L = ['%s=%r' % (key, value)
15788 
      for key, value in self.__dict__.iteritems()]
15789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15790 
 
15791 
  def __eq__(self, other):
15792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15793 
 
15794 
  def __ne__(self, other):
15795 
    return not (self == other)
15796 
 
15797 
class refundOrder_args:
15798 
  """
15799 
  Attributes:
15800 
   - orderId
3226 chandransh 15801 
   - refundedBy
15802 
   - reason
2616 chandransh 15803 
  """
15804 
 
15805 
  thrift_spec = (
15806 
    None, # 0
15807 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 15808 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
15809 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 15810 
  )
15811 
 
3226 chandransh 15812 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 15813 
    self.orderId = orderId
3226 chandransh 15814 
    self.refundedBy = refundedBy
15815 
    self.reason = reason
2616 chandransh 15816 
 
15817 
  def read(self, iprot):
15818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15820 
      return
15821 
    iprot.readStructBegin()
15822 
    while True:
15823 
      (fname, ftype, fid) = iprot.readFieldBegin()
15824 
      if ftype == TType.STOP:
15825 
        break
15826 
      if fid == 1:
15827 
        if ftype == TType.I64:
15828 
          self.orderId = iprot.readI64();
15829 
        else:
15830 
          iprot.skip(ftype)
3226 chandransh 15831 
      elif fid == 2:
15832 
        if ftype == TType.STRING:
15833 
          self.refundedBy = iprot.readString();
15834 
        else:
15835 
          iprot.skip(ftype)
15836 
      elif fid == 3:
15837 
        if ftype == TType.STRING:
15838 
          self.reason = iprot.readString();
15839 
        else:
15840 
          iprot.skip(ftype)
2616 chandransh 15841 
      else:
15842 
        iprot.skip(ftype)
15843 
      iprot.readFieldEnd()
15844 
    iprot.readStructEnd()
15845 
 
15846 
  def write(self, oprot):
15847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15849 
      return
15850 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 15851 
    if self.orderId is not None:
2616 chandransh 15852 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15853 
      oprot.writeI64(self.orderId)
15854 
      oprot.writeFieldEnd()
3431 rajveer 15855 
    if self.refundedBy is not None:
3226 chandransh 15856 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
15857 
      oprot.writeString(self.refundedBy)
15858 
      oprot.writeFieldEnd()
3431 rajveer 15859 
    if self.reason is not None:
3226 chandransh 15860 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
15861 
      oprot.writeString(self.reason)
15862 
      oprot.writeFieldEnd()
2616 chandransh 15863 
    oprot.writeFieldStop()
15864 
    oprot.writeStructEnd()
15865 
 
3431 rajveer 15866 
  def validate(self):
15867 
    return
15868 
 
15869 
 
2616 chandransh 15870 
  def __repr__(self):
15871 
    L = ['%s=%r' % (key, value)
15872 
      for key, value in self.__dict__.iteritems()]
15873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15874 
 
15875 
  def __eq__(self, other):
15876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15877 
 
15878 
  def __ne__(self, other):
15879 
    return not (self == other)
15880 
 
15881 
class refundOrder_result:
15882 
  """
15883 
  Attributes:
15884 
   - success
15885 
   - ex
15886 
  """
15887 
 
15888 
  thrift_spec = (
15889 
    (0, TType.BOOL, 'success', None, None, ), # 0
15890 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15891 
  )
15892 
 
15893 
  def __init__(self, success=None, ex=None,):
15894 
    self.success = success
15895 
    self.ex = ex
15896 
 
15897 
  def read(self, iprot):
15898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15900 
      return
15901 
    iprot.readStructBegin()
15902 
    while True:
15903 
      (fname, ftype, fid) = iprot.readFieldBegin()
15904 
      if ftype == TType.STOP:
15905 
        break
15906 
      if fid == 0:
15907 
        if ftype == TType.BOOL:
15908 
          self.success = iprot.readBool();
15909 
        else:
15910 
          iprot.skip(ftype)
15911 
      elif fid == 1:
15912 
        if ftype == TType.STRUCT:
15913 
          self.ex = TransactionServiceException()
15914 
          self.ex.read(iprot)
15915 
        else:
15916 
          iprot.skip(ftype)
15917 
      else:
15918 
        iprot.skip(ftype)
15919 
      iprot.readFieldEnd()
15920 
    iprot.readStructEnd()
15921 
 
15922 
  def write(self, oprot):
15923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15925 
      return
15926 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 15927 
    if self.success is not None:
2616 chandransh 15928 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15929 
      oprot.writeBool(self.success)
15930 
      oprot.writeFieldEnd()
3431 rajveer 15931 
    if self.ex is not None:
2616 chandransh 15932 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15933 
      self.ex.write(oprot)
15934 
      oprot.writeFieldEnd()
15935 
    oprot.writeFieldStop()
15936 
    oprot.writeStructEnd()
15937 
 
3431 rajveer 15938 
  def validate(self):
15939 
    return
15940 
 
15941 
 
2616 chandransh 15942 
  def __repr__(self):
15943 
    L = ['%s=%r' % (key, value)
15944 
      for key, value in self.__dict__.iteritems()]
15945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15946 
 
15947 
  def __eq__(self, other):
15948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15949 
 
15950 
  def __ne__(self, other):
15951 
    return not (self == other)
15952 
 
2690 chandransh 15953 
class getReturnOrders_args:
15954 
  """
15955 
  Attributes:
15956 
   - warehouseId
15957 
   - fromDate
15958 
   - toDate
15959 
  """
2616 chandransh 15960 
 
2690 chandransh 15961 
  thrift_spec = (
15962 
    None, # 0
15963 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
15964 
    (2, TType.I64, 'fromDate', None, None, ), # 2
15965 
    (3, TType.I64, 'toDate', None, None, ), # 3
15966 
  )
15967 
 
15968 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
15969 
    self.warehouseId = warehouseId
15970 
    self.fromDate = fromDate
15971 
    self.toDate = toDate
15972 
 
15973 
  def read(self, iprot):
15974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15976 
      return
15977 
    iprot.readStructBegin()
15978 
    while True:
15979 
      (fname, ftype, fid) = iprot.readFieldBegin()
15980 
      if ftype == TType.STOP:
15981 
        break
15982 
      if fid == 1:
15983 
        if ftype == TType.I64:
15984 
          self.warehouseId = iprot.readI64();
15985 
        else:
15986 
          iprot.skip(ftype)
15987 
      elif fid == 2:
15988 
        if ftype == TType.I64:
15989 
          self.fromDate = iprot.readI64();
15990 
        else:
15991 
          iprot.skip(ftype)
15992 
      elif fid == 3:
15993 
        if ftype == TType.I64:
15994 
          self.toDate = iprot.readI64();
15995 
        else:
15996 
          iprot.skip(ftype)
15997 
      else:
15998 
        iprot.skip(ftype)
15999 
      iprot.readFieldEnd()
16000 
    iprot.readStructEnd()
16001 
 
16002 
  def write(self, oprot):
16003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16005 
      return
16006 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 16007 
    if self.warehouseId is not None:
2690 chandransh 16008 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
16009 
      oprot.writeI64(self.warehouseId)
16010 
      oprot.writeFieldEnd()
3431 rajveer 16011 
    if self.fromDate is not None:
2690 chandransh 16012 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
16013 
      oprot.writeI64(self.fromDate)
16014 
      oprot.writeFieldEnd()
3431 rajveer 16015 
    if self.toDate is not None:
2690 chandransh 16016 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
16017 
      oprot.writeI64(self.toDate)
16018 
      oprot.writeFieldEnd()
16019 
    oprot.writeFieldStop()
16020 
    oprot.writeStructEnd()
16021 
 
3431 rajveer 16022 
  def validate(self):
16023 
    return
16024 
 
16025 
 
2690 chandransh 16026 
  def __repr__(self):
16027 
    L = ['%s=%r' % (key, value)
16028 
      for key, value in self.__dict__.iteritems()]
16029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16030 
 
16031 
  def __eq__(self, other):
16032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16033 
 
16034 
  def __ne__(self, other):
16035 
    return not (self == other)
16036 
 
16037 
class getReturnOrders_result:
16038 
  """
16039 
  Attributes:
16040 
   - success
16041 
  """
16042 
 
16043 
  thrift_spec = (
16044 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
16045 
  )
16046 
 
16047 
  def __init__(self, success=None,):
16048 
    self.success = success
16049 
 
16050 
  def read(self, iprot):
16051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16053 
      return
16054 
    iprot.readStructBegin()
16055 
    while True:
16056 
      (fname, ftype, fid) = iprot.readFieldBegin()
16057 
      if ftype == TType.STOP:
16058 
        break
16059 
      if fid == 0:
16060 
        if ftype == TType.LIST:
16061 
          self.success = []
5031 varun.gupt 16062 
          (_etype357, _size354) = iprot.readListBegin()
16063 
          for _i358 in xrange(_size354):
16064 
            _elem359 = ReturnOrder()
16065 
            _elem359.read(iprot)
16066 
            self.success.append(_elem359)
2690 chandransh 16067 
          iprot.readListEnd()
16068 
        else:
16069 
          iprot.skip(ftype)
16070 
      else:
16071 
        iprot.skip(ftype)
16072 
      iprot.readFieldEnd()
16073 
    iprot.readStructEnd()
16074 
 
16075 
  def write(self, oprot):
16076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16078 
      return
16079 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 16080 
    if self.success is not None:
2690 chandransh 16081 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16082 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 16083 
      for iter360 in self.success:
16084 
        iter360.write(oprot)
2690 chandransh 16085 
      oprot.writeListEnd()
16086 
      oprot.writeFieldEnd()
16087 
    oprot.writeFieldStop()
16088 
    oprot.writeStructEnd()
16089 
 
3431 rajveer 16090 
  def validate(self):
16091 
    return
16092 
 
16093 
 
2690 chandransh 16094 
  def __repr__(self):
16095 
    L = ['%s=%r' % (key, value)
16096 
      for key, value in self.__dict__.iteritems()]
16097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16098 
 
16099 
  def __eq__(self, other):
16100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16101 
 
16102 
  def __ne__(self, other):
16103 
    return not (self == other)
16104 
 
2700 chandransh 16105 
class getReturnOrder_args:
16106 
  """
16107 
  Attributes:
16108 
   - id
16109 
  """
16110 
 
16111 
  thrift_spec = (
16112 
    None, # 0
16113 
    (1, TType.I64, 'id', None, None, ), # 1
16114 
  )
16115 
 
16116 
  def __init__(self, id=None,):
16117 
    self.id = id
16118 
 
16119 
  def read(self, iprot):
16120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16122 
      return
16123 
    iprot.readStructBegin()
16124 
    while True:
16125 
      (fname, ftype, fid) = iprot.readFieldBegin()
16126 
      if ftype == TType.STOP:
16127 
        break
16128 
      if fid == 1:
16129 
        if ftype == TType.I64:
16130 
          self.id = iprot.readI64();
16131 
        else:
16132 
          iprot.skip(ftype)
16133 
      else:
16134 
        iprot.skip(ftype)
16135 
      iprot.readFieldEnd()
16136 
    iprot.readStructEnd()
16137 
 
16138 
  def write(self, oprot):
16139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16141 
      return
16142 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 16143 
    if self.id is not None:
2700 chandransh 16144 
      oprot.writeFieldBegin('id', TType.I64, 1)
16145 
      oprot.writeI64(self.id)
16146 
      oprot.writeFieldEnd()
16147 
    oprot.writeFieldStop()
16148 
    oprot.writeStructEnd()
16149 
 
3431 rajveer 16150 
  def validate(self):
16151 
    return
16152 
 
16153 
 
2700 chandransh 16154 
  def __repr__(self):
16155 
    L = ['%s=%r' % (key, value)
16156 
      for key, value in self.__dict__.iteritems()]
16157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16158 
 
16159 
  def __eq__(self, other):
16160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16161 
 
16162 
  def __ne__(self, other):
16163 
    return not (self == other)
16164 
 
16165 
class getReturnOrder_result:
16166 
  """
16167 
  Attributes:
16168 
   - success
16169 
   - ex
16170 
  """
16171 
 
16172 
  thrift_spec = (
16173 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
16174 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16175 
  )
16176 
 
16177 
  def __init__(self, success=None, ex=None,):
16178 
    self.success = success
16179 
    self.ex = ex
16180 
 
16181 
  def read(self, iprot):
16182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16184 
      return
16185 
    iprot.readStructBegin()
16186 
    while True:
16187 
      (fname, ftype, fid) = iprot.readFieldBegin()
16188 
      if ftype == TType.STOP:
16189 
        break
16190 
      if fid == 0:
16191 
        if ftype == TType.STRUCT:
16192 
          self.success = ReturnOrder()
16193 
          self.success.read(iprot)
16194 
        else:
16195 
          iprot.skip(ftype)
16196 
      elif fid == 1:
16197 
        if ftype == TType.STRUCT:
16198 
          self.ex = TransactionServiceException()
16199 
          self.ex.read(iprot)
16200 
        else:
16201 
          iprot.skip(ftype)
16202 
      else:
16203 
        iprot.skip(ftype)
16204 
      iprot.readFieldEnd()
16205 
    iprot.readStructEnd()
16206 
 
16207 
  def write(self, oprot):
16208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16210 
      return
16211 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 16212 
    if self.success is not None:
2700 chandransh 16213 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16214 
      self.success.write(oprot)
16215 
      oprot.writeFieldEnd()
3431 rajveer 16216 
    if self.ex is not None:
2700 chandransh 16217 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16218 
      self.ex.write(oprot)
16219 
      oprot.writeFieldEnd()
16220 
    oprot.writeFieldStop()
16221 
    oprot.writeStructEnd()
16222 
 
3431 rajveer 16223 
  def validate(self):
16224 
    return
16225 
 
16226 
 
2700 chandransh 16227 
  def __repr__(self):
16228 
    L = ['%s=%r' % (key, value)
16229 
      for key, value in self.__dict__.iteritems()]
16230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16231 
 
16232 
  def __eq__(self, other):
16233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16234 
 
16235 
  def __ne__(self, other):
16236 
    return not (self == other)
16237 
 
2690 chandransh 16238 
class processReturn_args:
16239 
  """
16240 
  Attributes:
16241 
   - returnOrderId
16242 
  """
16243 
 
16244 
  thrift_spec = (
16245 
    None, # 0
16246 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
16247 
  )
16248 
 
16249 
  def __init__(self, returnOrderId=None,):
16250 
    self.returnOrderId = returnOrderId
16251 
 
16252 
  def read(self, iprot):
16253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16255 
      return
16256 
    iprot.readStructBegin()
16257 
    while True:
16258 
      (fname, ftype, fid) = iprot.readFieldBegin()
16259 
      if ftype == TType.STOP:
16260 
        break
16261 
      if fid == 1:
16262 
        if ftype == TType.I64:
16263 
          self.returnOrderId = iprot.readI64();
16264 
        else:
16265 
          iprot.skip(ftype)
16266 
      else:
16267 
        iprot.skip(ftype)
16268 
      iprot.readFieldEnd()
16269 
    iprot.readStructEnd()
16270 
 
16271 
  def write(self, oprot):
16272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16274 
      return
16275 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 16276 
    if self.returnOrderId is not None:
2690 chandransh 16277 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
16278 
      oprot.writeI64(self.returnOrderId)
16279 
      oprot.writeFieldEnd()
16280 
    oprot.writeFieldStop()
16281 
    oprot.writeStructEnd()
16282 
 
3431 rajveer 16283 
  def validate(self):
16284 
    return
16285 
 
16286 
 
2690 chandransh 16287 
  def __repr__(self):
16288 
    L = ['%s=%r' % (key, value)
16289 
      for key, value in self.__dict__.iteritems()]
16290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16291 
 
16292 
  def __eq__(self, other):
16293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16294 
 
16295 
  def __ne__(self, other):
16296 
    return not (self == other)
16297 
 
16298 
class processReturn_result:
16299 
  """
16300 
  Attributes:
16301 
   - ex
16302 
  """
16303 
 
16304 
  thrift_spec = (
16305 
    None, # 0
16306 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16307 
  )
16308 
 
16309 
  def __init__(self, ex=None,):
16310 
    self.ex = ex
16311 
 
16312 
  def read(self, iprot):
16313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16315 
      return
16316 
    iprot.readStructBegin()
16317 
    while True:
16318 
      (fname, ftype, fid) = iprot.readFieldBegin()
16319 
      if ftype == TType.STOP:
16320 
        break
16321 
      if fid == 1:
16322 
        if ftype == TType.STRUCT:
16323 
          self.ex = TransactionServiceException()
16324 
          self.ex.read(iprot)
16325 
        else:
16326 
          iprot.skip(ftype)
16327 
      else:
16328 
        iprot.skip(ftype)
16329 
      iprot.readFieldEnd()
16330 
    iprot.readStructEnd()
16331 
 
16332 
  def write(self, oprot):
16333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16335 
      return
16336 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 16337 
    if self.ex is not None:
2690 chandransh 16338 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16339 
      self.ex.write(oprot)
16340 
      oprot.writeFieldEnd()
16341 
    oprot.writeFieldStop()
16342 
    oprot.writeStructEnd()
16343 
 
3431 rajveer 16344 
  def validate(self):
16345 
    return
16346 
 
16347 
 
2690 chandransh 16348 
  def __repr__(self):
16349 
    L = ['%s=%r' % (key, value)
16350 
      for key, value in self.__dict__.iteritems()]
16351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16352 
 
16353 
  def __eq__(self, other):
16354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16355 
 
16356 
  def __ne__(self, other):
16357 
    return not (self == other)
16358 
 
3451 chandransh 16359 
class updateWeight_args:
16360 
  """
16361 
  Attributes:
16362 
   - orderId
16363 
   - weight
16364 
  """
16365 
 
16366 
  thrift_spec = (
16367 
    None, # 0
16368 
    (1, TType.I64, 'orderId', None, None, ), # 1
16369 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
16370 
  )
16371 
 
16372 
  def __init__(self, orderId=None, weight=None,):
16373 
    self.orderId = orderId
16374 
    self.weight = weight
16375 
 
16376 
  def read(self, iprot):
16377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16379 
      return
16380 
    iprot.readStructBegin()
16381 
    while True:
16382 
      (fname, ftype, fid) = iprot.readFieldBegin()
16383 
      if ftype == TType.STOP:
16384 
        break
16385 
      if fid == 1:
16386 
        if ftype == TType.I64:
16387 
          self.orderId = iprot.readI64();
16388 
        else:
16389 
          iprot.skip(ftype)
16390 
      elif fid == 2:
16391 
        if ftype == TType.DOUBLE:
16392 
          self.weight = iprot.readDouble();
16393 
        else:
16394 
          iprot.skip(ftype)
16395 
      else:
16396 
        iprot.skip(ftype)
16397 
      iprot.readFieldEnd()
16398 
    iprot.readStructEnd()
16399 
 
16400 
  def write(self, oprot):
16401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16403 
      return
16404 
    oprot.writeStructBegin('updateWeight_args')
16405 
    if self.orderId is not None:
16406 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16407 
      oprot.writeI64(self.orderId)
16408 
      oprot.writeFieldEnd()
16409 
    if self.weight is not None:
16410 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
16411 
      oprot.writeDouble(self.weight)
16412 
      oprot.writeFieldEnd()
16413 
    oprot.writeFieldStop()
16414 
    oprot.writeStructEnd()
16415 
 
16416 
  def validate(self):
16417 
    return
16418 
 
16419 
 
16420 
  def __repr__(self):
16421 
    L = ['%s=%r' % (key, value)
16422 
      for key, value in self.__dict__.iteritems()]
16423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16424 
 
16425 
  def __eq__(self, other):
16426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16427 
 
16428 
  def __ne__(self, other):
16429 
    return not (self == other)
16430 
 
16431 
class updateWeight_result:
16432 
  """
16433 
  Attributes:
16434 
   - success
16435 
   - ex
16436 
  """
16437 
 
16438 
  thrift_spec = (
16439 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16440 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16441 
  )
16442 
 
16443 
  def __init__(self, success=None, ex=None,):
16444 
    self.success = success
16445 
    self.ex = ex
16446 
 
16447 
  def read(self, iprot):
16448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16450 
      return
16451 
    iprot.readStructBegin()
16452 
    while True:
16453 
      (fname, ftype, fid) = iprot.readFieldBegin()
16454 
      if ftype == TType.STOP:
16455 
        break
16456 
      if fid == 0:
16457 
        if ftype == TType.STRUCT:
16458 
          self.success = Order()
16459 
          self.success.read(iprot)
16460 
        else:
16461 
          iprot.skip(ftype)
16462 
      elif fid == 1:
16463 
        if ftype == TType.STRUCT:
16464 
          self.ex = TransactionServiceException()
16465 
          self.ex.read(iprot)
16466 
        else:
16467 
          iprot.skip(ftype)
16468 
      else:
16469 
        iprot.skip(ftype)
16470 
      iprot.readFieldEnd()
16471 
    iprot.readStructEnd()
16472 
 
16473 
  def write(self, oprot):
16474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16476 
      return
16477 
    oprot.writeStructBegin('updateWeight_result')
16478 
    if self.success is not None:
16479 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16480 
      self.success.write(oprot)
16481 
      oprot.writeFieldEnd()
16482 
    if self.ex is not None:
16483 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16484 
      self.ex.write(oprot)
16485 
      oprot.writeFieldEnd()
16486 
    oprot.writeFieldStop()
16487 
    oprot.writeStructEnd()
16488 
 
16489 
  def validate(self):
16490 
    return
16491 
 
16492 
 
16493 
  def __repr__(self):
16494 
    L = ['%s=%r' % (key, value)
16495 
      for key, value in self.__dict__.iteritems()]
16496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16497 
 
16498 
  def __eq__(self, other):
16499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16500 
 
16501 
  def __ne__(self, other):
16502 
    return not (self == other)
3469 chandransh 16503 
 
16504 
class changeItem_args:
16505 
  """
16506 
  Attributes:
16507 
   - orderId
16508 
   - itemId
16509 
  """
16510 
 
16511 
  thrift_spec = (
16512 
    None, # 0
16513 
    (1, TType.I64, 'orderId', None, None, ), # 1
16514 
    (2, TType.I64, 'itemId', None, None, ), # 2
16515 
  )
16516 
 
16517 
  def __init__(self, orderId=None, itemId=None,):
16518 
    self.orderId = orderId
16519 
    self.itemId = itemId
16520 
 
16521 
  def read(self, iprot):
16522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16524 
      return
16525 
    iprot.readStructBegin()
16526 
    while True:
16527 
      (fname, ftype, fid) = iprot.readFieldBegin()
16528 
      if ftype == TType.STOP:
16529 
        break
16530 
      if fid == 1:
16531 
        if ftype == TType.I64:
16532 
          self.orderId = iprot.readI64();
16533 
        else:
16534 
          iprot.skip(ftype)
16535 
      elif fid == 2:
16536 
        if ftype == TType.I64:
16537 
          self.itemId = iprot.readI64();
16538 
        else:
16539 
          iprot.skip(ftype)
16540 
      else:
16541 
        iprot.skip(ftype)
16542 
      iprot.readFieldEnd()
16543 
    iprot.readStructEnd()
16544 
 
16545 
  def write(self, oprot):
16546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16548 
      return
16549 
    oprot.writeStructBegin('changeItem_args')
16550 
    if self.orderId is not None:
16551 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16552 
      oprot.writeI64(self.orderId)
16553 
      oprot.writeFieldEnd()
16554 
    if self.itemId is not None:
16555 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16556 
      oprot.writeI64(self.itemId)
16557 
      oprot.writeFieldEnd()
16558 
    oprot.writeFieldStop()
16559 
    oprot.writeStructEnd()
16560 
 
16561 
  def validate(self):
16562 
    return
16563 
 
16564 
 
16565 
  def __repr__(self):
16566 
    L = ['%s=%r' % (key, value)
16567 
      for key, value in self.__dict__.iteritems()]
16568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16569 
 
16570 
  def __eq__(self, other):
16571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16572 
 
16573 
  def __ne__(self, other):
16574 
    return not (self == other)
16575 
 
16576 
class changeItem_result:
16577 
  """
16578 
  Attributes:
16579 
   - success
16580 
   - ex
16581 
  """
16582 
 
16583 
  thrift_spec = (
16584 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16585 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16586 
  )
16587 
 
16588 
  def __init__(self, success=None, ex=None,):
16589 
    self.success = success
16590 
    self.ex = ex
16591 
 
16592 
  def read(self, iprot):
16593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16595 
      return
16596 
    iprot.readStructBegin()
16597 
    while True:
16598 
      (fname, ftype, fid) = iprot.readFieldBegin()
16599 
      if ftype == TType.STOP:
16600 
        break
16601 
      if fid == 0:
16602 
        if ftype == TType.STRUCT:
16603 
          self.success = Order()
16604 
          self.success.read(iprot)
16605 
        else:
16606 
          iprot.skip(ftype)
16607 
      elif fid == 1:
16608 
        if ftype == TType.STRUCT:
16609 
          self.ex = TransactionServiceException()
16610 
          self.ex.read(iprot)
16611 
        else:
16612 
          iprot.skip(ftype)
16613 
      else:
16614 
        iprot.skip(ftype)
16615 
      iprot.readFieldEnd()
16616 
    iprot.readStructEnd()
16617 
 
16618 
  def write(self, oprot):
16619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16621 
      return
16622 
    oprot.writeStructBegin('changeItem_result')
16623 
    if self.success is not None:
16624 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16625 
      self.success.write(oprot)
16626 
      oprot.writeFieldEnd()
16627 
    if self.ex is not None:
16628 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16629 
      self.ex.write(oprot)
16630 
      oprot.writeFieldEnd()
16631 
    oprot.writeFieldStop()
16632 
    oprot.writeStructEnd()
16633 
 
16634 
  def validate(self):
16635 
    return
16636 
 
16637 
 
16638 
  def __repr__(self):
16639 
    L = ['%s=%r' % (key, value)
16640 
      for key, value in self.__dict__.iteritems()]
16641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16642 
 
16643 
  def __eq__(self, other):
16644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16645 
 
16646 
  def __ne__(self, other):
16647 
    return not (self == other)
16648 
 
16649 
class shiftToWarehouse_args:
16650 
  """
16651 
  Attributes:
16652 
   - orderId
16653 
   - warehouseId
16654 
  """
16655 
 
16656 
  thrift_spec = (
16657 
    None, # 0
16658 
    (1, TType.I64, 'orderId', None, None, ), # 1
16659 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
16660 
  )
16661 
 
16662 
  def __init__(self, orderId=None, warehouseId=None,):
16663 
    self.orderId = orderId
16664 
    self.warehouseId = warehouseId
16665 
 
16666 
  def read(self, iprot):
16667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16669 
      return
16670 
    iprot.readStructBegin()
16671 
    while True:
16672 
      (fname, ftype, fid) = iprot.readFieldBegin()
16673 
      if ftype == TType.STOP:
16674 
        break
16675 
      if fid == 1:
16676 
        if ftype == TType.I64:
16677 
          self.orderId = iprot.readI64();
16678 
        else:
16679 
          iprot.skip(ftype)
16680 
      elif fid == 2:
16681 
        if ftype == TType.I64:
16682 
          self.warehouseId = iprot.readI64();
16683 
        else:
16684 
          iprot.skip(ftype)
16685 
      else:
16686 
        iprot.skip(ftype)
16687 
      iprot.readFieldEnd()
16688 
    iprot.readStructEnd()
16689 
 
16690 
  def write(self, oprot):
16691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16693 
      return
16694 
    oprot.writeStructBegin('shiftToWarehouse_args')
16695 
    if self.orderId is not None:
16696 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16697 
      oprot.writeI64(self.orderId)
16698 
      oprot.writeFieldEnd()
16699 
    if self.warehouseId is not None:
16700 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16701 
      oprot.writeI64(self.warehouseId)
16702 
      oprot.writeFieldEnd()
16703 
    oprot.writeFieldStop()
16704 
    oprot.writeStructEnd()
16705 
 
16706 
  def validate(self):
16707 
    return
16708 
 
16709 
 
16710 
  def __repr__(self):
16711 
    L = ['%s=%r' % (key, value)
16712 
      for key, value in self.__dict__.iteritems()]
16713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16714 
 
16715 
  def __eq__(self, other):
16716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16717 
 
16718 
  def __ne__(self, other):
16719 
    return not (self == other)
16720 
 
16721 
class shiftToWarehouse_result:
16722 
  """
16723 
  Attributes:
16724 
   - success
16725 
   - ex
16726 
  """
16727 
 
16728 
  thrift_spec = (
16729 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16730 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16731 
  )
16732 
 
16733 
  def __init__(self, success=None, ex=None,):
16734 
    self.success = success
16735 
    self.ex = ex
16736 
 
16737 
  def read(self, iprot):
16738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16740 
      return
16741 
    iprot.readStructBegin()
16742 
    while True:
16743 
      (fname, ftype, fid) = iprot.readFieldBegin()
16744 
      if ftype == TType.STOP:
16745 
        break
16746 
      if fid == 0:
16747 
        if ftype == TType.STRUCT:
16748 
          self.success = Order()
16749 
          self.success.read(iprot)
16750 
        else:
16751 
          iprot.skip(ftype)
16752 
      elif fid == 1:
16753 
        if ftype == TType.STRUCT:
16754 
          self.ex = TransactionServiceException()
16755 
          self.ex.read(iprot)
16756 
        else:
16757 
          iprot.skip(ftype)
16758 
      else:
16759 
        iprot.skip(ftype)
16760 
      iprot.readFieldEnd()
16761 
    iprot.readStructEnd()
16762 
 
16763 
  def write(self, oprot):
16764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16766 
      return
16767 
    oprot.writeStructBegin('shiftToWarehouse_result')
16768 
    if self.success is not None:
16769 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16770 
      self.success.write(oprot)
16771 
      oprot.writeFieldEnd()
16772 
    if self.ex is not None:
16773 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16774 
      self.ex.write(oprot)
16775 
      oprot.writeFieldEnd()
16776 
    oprot.writeFieldStop()
16777 
    oprot.writeStructEnd()
16778 
 
16779 
  def validate(self):
16780 
    return
16781 
 
16782 
 
16783 
  def __repr__(self):
16784 
    L = ['%s=%r' % (key, value)
16785 
      for key, value in self.__dict__.iteritems()]
16786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16787 
 
16788 
  def __eq__(self, other):
16789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16790 
 
16791 
  def __ne__(self, other):
16792 
    return not (self == other)
3553 chandransh 16793 
 
16794 
class addDelayReason_args:
16795 
  """
16796 
  Attributes:
16797 
   - orderId
16798 
   - delayReason
3986 chandransh 16799 
   - furtherDelay
4647 rajveer 16800 
   - delayReasonText
3553 chandransh 16801 
  """
16802 
 
16803 
  thrift_spec = (
16804 
    None, # 0
16805 
    (1, TType.I64, 'orderId', None, None, ), # 1
16806 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 16807 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 16808 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 16809 
  )
16810 
 
4647 rajveer 16811 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 16812 
    self.orderId = orderId
16813 
    self.delayReason = delayReason
3986 chandransh 16814 
    self.furtherDelay = furtherDelay
4647 rajveer 16815 
    self.delayReasonText = delayReasonText
3553 chandransh 16816 
 
16817 
  def read(self, iprot):
16818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16820 
      return
16821 
    iprot.readStructBegin()
16822 
    while True:
16823 
      (fname, ftype, fid) = iprot.readFieldBegin()
16824 
      if ftype == TType.STOP:
16825 
        break
16826 
      if fid == 1:
16827 
        if ftype == TType.I64:
16828 
          self.orderId = iprot.readI64();
16829 
        else:
16830 
          iprot.skip(ftype)
16831 
      elif fid == 2:
16832 
        if ftype == TType.I32:
16833 
          self.delayReason = iprot.readI32();
16834 
        else:
16835 
          iprot.skip(ftype)
3986 chandransh 16836 
      elif fid == 3:
16837 
        if ftype == TType.I64:
16838 
          self.furtherDelay = iprot.readI64();
16839 
        else:
16840 
          iprot.skip(ftype)
4647 rajveer 16841 
      elif fid == 4:
16842 
        if ftype == TType.STRING:
16843 
          self.delayReasonText = iprot.readString();
16844 
        else:
16845 
          iprot.skip(ftype)
3553 chandransh 16846 
      else:
16847 
        iprot.skip(ftype)
16848 
      iprot.readFieldEnd()
16849 
    iprot.readStructEnd()
16850 
 
16851 
  def write(self, oprot):
16852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16854 
      return
16855 
    oprot.writeStructBegin('addDelayReason_args')
16856 
    if self.orderId is not None:
16857 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16858 
      oprot.writeI64(self.orderId)
16859 
      oprot.writeFieldEnd()
16860 
    if self.delayReason is not None:
16861 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
16862 
      oprot.writeI32(self.delayReason)
16863 
      oprot.writeFieldEnd()
3986 chandransh 16864 
    if self.furtherDelay is not None:
16865 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
16866 
      oprot.writeI64(self.furtherDelay)
16867 
      oprot.writeFieldEnd()
4647 rajveer 16868 
    if self.delayReasonText is not None:
16869 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
16870 
      oprot.writeString(self.delayReasonText)
16871 
      oprot.writeFieldEnd()
3553 chandransh 16872 
    oprot.writeFieldStop()
16873 
    oprot.writeStructEnd()
16874 
 
16875 
  def validate(self):
16876 
    return
16877 
 
16878 
 
16879 
  def __repr__(self):
16880 
    L = ['%s=%r' % (key, value)
16881 
      for key, value in self.__dict__.iteritems()]
16882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16883 
 
16884 
  def __eq__(self, other):
16885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16886 
 
16887 
  def __ne__(self, other):
16888 
    return not (self == other)
16889 
 
16890 
class addDelayReason_result:
16891 
  """
16892 
  Attributes:
16893 
   - success
16894 
   - ex
16895 
  """
16896 
 
16897 
  thrift_spec = (
16898 
    (0, TType.BOOL, 'success', None, None, ), # 0
16899 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16900 
  )
16901 
 
16902 
  def __init__(self, success=None, ex=None,):
16903 
    self.success = success
16904 
    self.ex = ex
16905 
 
16906 
  def read(self, iprot):
16907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16909 
      return
16910 
    iprot.readStructBegin()
16911 
    while True:
16912 
      (fname, ftype, fid) = iprot.readFieldBegin()
16913 
      if ftype == TType.STOP:
16914 
        break
16915 
      if fid == 0:
16916 
        if ftype == TType.BOOL:
16917 
          self.success = iprot.readBool();
16918 
        else:
16919 
          iprot.skip(ftype)
16920 
      elif fid == 1:
16921 
        if ftype == TType.STRUCT:
16922 
          self.ex = TransactionServiceException()
16923 
          self.ex.read(iprot)
16924 
        else:
16925 
          iprot.skip(ftype)
16926 
      else:
16927 
        iprot.skip(ftype)
16928 
      iprot.readFieldEnd()
16929 
    iprot.readStructEnd()
16930 
 
16931 
  def write(self, oprot):
16932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16934 
      return
16935 
    oprot.writeStructBegin('addDelayReason_result')
16936 
    if self.success is not None:
16937 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16938 
      oprot.writeBool(self.success)
16939 
      oprot.writeFieldEnd()
16940 
    if self.ex is not None:
16941 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16942 
      self.ex.write(oprot)
16943 
      oprot.writeFieldEnd()
16944 
    oprot.writeFieldStop()
16945 
    oprot.writeStructEnd()
16946 
 
16947 
  def validate(self):
16948 
    return
16949 
 
16950 
 
16951 
  def __repr__(self):
16952 
    L = ['%s=%r' % (key, value)
16953 
      for key, value in self.__dict__.iteritems()]
16954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16955 
 
16956 
  def __eq__(self, other):
16957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16958 
 
16959 
  def __ne__(self, other):
16960 
    return not (self == other)
3956 chandransh 16961 
 
16962 
class reconcileCodCollection_args:
16963 
  """
16964 
  Attributes:
16965 
   - collectedAmountMap
16966 
   - xferBy
16967 
   - xferTxnId
16968 
   - xferDate
16969 
  """
16970 
 
16971 
  thrift_spec = (
16972 
    None, # 0
16973 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
16974 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
16975 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
16976 
    (4, TType.I64, 'xferDate', None, None, ), # 4
16977 
  )
16978 
 
16979 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
16980 
    self.collectedAmountMap = collectedAmountMap
16981 
    self.xferBy = xferBy
16982 
    self.xferTxnId = xferTxnId
16983 
    self.xferDate = xferDate
16984 
 
16985 
  def read(self, iprot):
16986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16988 
      return
16989 
    iprot.readStructBegin()
16990 
    while True:
16991 
      (fname, ftype, fid) = iprot.readFieldBegin()
16992 
      if ftype == TType.STOP:
16993 
        break
16994 
      if fid == 1:
16995 
        if ftype == TType.MAP:
16996 
          self.collectedAmountMap = {}
5031 varun.gupt 16997 
          (_ktype362, _vtype363, _size361 ) = iprot.readMapBegin()
16998 
          for _i365 in xrange(_size361):
16999 
            _key366 = iprot.readString();
17000 
            _val367 = iprot.readDouble();
17001 
            self.collectedAmountMap[_key366] = _val367
3956 chandransh 17002 
          iprot.readMapEnd()
17003 
        else:
17004 
          iprot.skip(ftype)
17005 
      elif fid == 2:
17006 
        if ftype == TType.STRING:
17007 
          self.xferBy = iprot.readString();
17008 
        else:
17009 
          iprot.skip(ftype)
17010 
      elif fid == 3:
17011 
        if ftype == TType.STRING:
17012 
          self.xferTxnId = iprot.readString();
17013 
        else:
17014 
          iprot.skip(ftype)
17015 
      elif fid == 4:
17016 
        if ftype == TType.I64:
17017 
          self.xferDate = iprot.readI64();
17018 
        else:
17019 
          iprot.skip(ftype)
17020 
      else:
17021 
        iprot.skip(ftype)
17022 
      iprot.readFieldEnd()
17023 
    iprot.readStructEnd()
17024 
 
17025 
  def write(self, oprot):
17026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17028 
      return
17029 
    oprot.writeStructBegin('reconcileCodCollection_args')
17030 
    if self.collectedAmountMap is not None:
17031 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
17032 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
5031 varun.gupt 17033 
      for kiter368,viter369 in self.collectedAmountMap.items():
17034 
        oprot.writeString(kiter368)
17035 
        oprot.writeDouble(viter369)
3956 chandransh 17036 
      oprot.writeMapEnd()
17037 
      oprot.writeFieldEnd()
17038 
    if self.xferBy is not None:
17039 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
17040 
      oprot.writeString(self.xferBy)
17041 
      oprot.writeFieldEnd()
17042 
    if self.xferTxnId is not None:
17043 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
17044 
      oprot.writeString(self.xferTxnId)
17045 
      oprot.writeFieldEnd()
17046 
    if self.xferDate is not None:
17047 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
17048 
      oprot.writeI64(self.xferDate)
17049 
      oprot.writeFieldEnd()
17050 
    oprot.writeFieldStop()
17051 
    oprot.writeStructEnd()
17052 
 
17053 
  def validate(self):
17054 
    return
17055 
 
17056 
 
17057 
  def __repr__(self):
17058 
    L = ['%s=%r' % (key, value)
17059 
      for key, value in self.__dict__.iteritems()]
17060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17061 
 
17062 
  def __eq__(self, other):
17063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17064 
 
17065 
  def __ne__(self, other):
17066 
    return not (self == other)
17067 
 
17068 
class reconcileCodCollection_result:
17069 
  """
17070 
  Attributes:
17071 
   - success
17072 
   - ex
17073 
  """
17074 
 
17075 
  thrift_spec = (
17076 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
17077 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17078 
  )
17079 
 
17080 
  def __init__(self, success=None, ex=None,):
17081 
    self.success = success
17082 
    self.ex = ex
17083 
 
17084 
  def read(self, iprot):
17085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17087 
      return
17088 
    iprot.readStructBegin()
17089 
    while True:
17090 
      (fname, ftype, fid) = iprot.readFieldBegin()
17091 
      if ftype == TType.STOP:
17092 
        break
17093 
      if fid == 0:
17094 
        if ftype == TType.MAP:
17095 
          self.success = {}
5031 varun.gupt 17096 
          (_ktype371, _vtype372, _size370 ) = iprot.readMapBegin()
17097 
          for _i374 in xrange(_size370):
17098 
            _key375 = iprot.readString();
17099 
            _val376 = iprot.readString();
17100 
            self.success[_key375] = _val376
3956 chandransh 17101 
          iprot.readMapEnd()
17102 
        else:
17103 
          iprot.skip(ftype)
17104 
      elif fid == 1:
17105 
        if ftype == TType.STRUCT:
17106 
          self.ex = TransactionServiceException()
17107 
          self.ex.read(iprot)
17108 
        else:
17109 
          iprot.skip(ftype)
17110 
      else:
17111 
        iprot.skip(ftype)
17112 
      iprot.readFieldEnd()
17113 
    iprot.readStructEnd()
17114 
 
17115 
  def write(self, oprot):
17116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17118 
      return
17119 
    oprot.writeStructBegin('reconcileCodCollection_result')
17120 
    if self.success is not None:
17121 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17122 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
5031 varun.gupt 17123 
      for kiter377,viter378 in self.success.items():
17124 
        oprot.writeString(kiter377)
17125 
        oprot.writeString(viter378)
3956 chandransh 17126 
      oprot.writeMapEnd()
17127 
      oprot.writeFieldEnd()
17128 
    if self.ex is not None:
17129 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17130 
      self.ex.write(oprot)
17131 
      oprot.writeFieldEnd()
17132 
    oprot.writeFieldStop()
17133 
    oprot.writeStructEnd()
17134 
 
17135 
  def validate(self):
17136 
    return
17137 
 
17138 
 
17139 
  def __repr__(self):
17140 
    L = ['%s=%r' % (key, value)
17141 
      for key, value in self.__dict__.iteritems()]
17142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17143 
 
17144 
  def __eq__(self, other):
17145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17146 
 
17147 
  def __ne__(self, other):
17148 
    return not (self == other)
4008 mandeep.dh 17149 
 
17150 
class getTransactionsRequiringExtraProcessing_args:
17151 
  """
17152 
  Attributes:
17153 
   - category
17154 
  """
17155 
 
17156 
  thrift_spec = (
17157 
    None, # 0
17158 
    (1, TType.I32, 'category', None, None, ), # 1
17159 
  )
17160 
 
17161 
  def __init__(self, category=None,):
17162 
    self.category = category
17163 
 
17164 
  def read(self, iprot):
17165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17167 
      return
17168 
    iprot.readStructBegin()
17169 
    while True:
17170 
      (fname, ftype, fid) = iprot.readFieldBegin()
17171 
      if ftype == TType.STOP:
17172 
        break
17173 
      if fid == 1:
17174 
        if ftype == TType.I32:
17175 
          self.category = iprot.readI32();
17176 
        else:
17177 
          iprot.skip(ftype)
17178 
      else:
17179 
        iprot.skip(ftype)
17180 
      iprot.readFieldEnd()
17181 
    iprot.readStructEnd()
17182 
 
17183 
  def write(self, oprot):
17184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17186 
      return
17187 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
17188 
    if self.category is not None:
17189 
      oprot.writeFieldBegin('category', TType.I32, 1)
17190 
      oprot.writeI32(self.category)
17191 
      oprot.writeFieldEnd()
17192 
    oprot.writeFieldStop()
17193 
    oprot.writeStructEnd()
17194 
 
17195 
  def validate(self):
17196 
    return
17197 
 
17198 
 
17199 
  def __repr__(self):
17200 
    L = ['%s=%r' % (key, value)
17201 
      for key, value in self.__dict__.iteritems()]
17202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17203 
 
17204 
  def __eq__(self, other):
17205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17206 
 
17207 
  def __ne__(self, other):
17208 
    return not (self == other)
17209 
 
17210 
class getTransactionsRequiringExtraProcessing_result:
17211 
  """
17212 
  Attributes:
17213 
   - success
17214 
  """
17215 
 
17216 
  thrift_spec = (
17217 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
17218 
  )
17219 
 
17220 
  def __init__(self, success=None,):
17221 
    self.success = success
17222 
 
17223 
  def read(self, iprot):
17224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17226 
      return
17227 
    iprot.readStructBegin()
17228 
    while True:
17229 
      (fname, ftype, fid) = iprot.readFieldBegin()
17230 
      if ftype == TType.STOP:
17231 
        break
17232 
      if fid == 0:
17233 
        if ftype == TType.LIST:
17234 
          self.success = []
5031 varun.gupt 17235 
          (_etype382, _size379) = iprot.readListBegin()
17236 
          for _i383 in xrange(_size379):
17237 
            _elem384 = iprot.readI64();
17238 
            self.success.append(_elem384)
4008 mandeep.dh 17239 
          iprot.readListEnd()
17240 
        else:
17241 
          iprot.skip(ftype)
17242 
      else:
17243 
        iprot.skip(ftype)
17244 
      iprot.readFieldEnd()
17245 
    iprot.readStructEnd()
17246 
 
17247 
  def write(self, oprot):
17248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17250 
      return
17251 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
17252 
    if self.success is not None:
17253 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17254 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 17255 
      for iter385 in self.success:
17256 
        oprot.writeI64(iter385)
4008 mandeep.dh 17257 
      oprot.writeListEnd()
17258 
      oprot.writeFieldEnd()
17259 
    oprot.writeFieldStop()
17260 
    oprot.writeStructEnd()
17261 
 
17262 
  def validate(self):
17263 
    return
17264 
 
17265 
 
17266 
  def __repr__(self):
17267 
    L = ['%s=%r' % (key, value)
17268 
      for key, value in self.__dict__.iteritems()]
17269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17270 
 
17271 
  def __eq__(self, other):
17272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17273 
 
17274 
  def __ne__(self, other):
17275 
    return not (self == other)
17276 
 
17277 
class markTransactionAsProcessed_args:
17278 
  """
17279 
  Attributes:
17280 
   - transactionId
17281 
   - category
17282 
  """
17283 
 
17284 
  thrift_spec = (
17285 
    None, # 0
17286 
    (1, TType.I64, 'transactionId', None, None, ), # 1
17287 
    (2, TType.I32, 'category', None, None, ), # 2
17288 
  )
17289 
 
17290 
  def __init__(self, transactionId=None, category=None,):
17291 
    self.transactionId = transactionId
17292 
    self.category = category
17293 
 
17294 
  def read(self, iprot):
17295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17297 
      return
17298 
    iprot.readStructBegin()
17299 
    while True:
17300 
      (fname, ftype, fid) = iprot.readFieldBegin()
17301 
      if ftype == TType.STOP:
17302 
        break
17303 
      if fid == 1:
17304 
        if ftype == TType.I64:
17305 
          self.transactionId = iprot.readI64();
17306 
        else:
17307 
          iprot.skip(ftype)
17308 
      elif fid == 2:
17309 
        if ftype == TType.I32:
17310 
          self.category = iprot.readI32();
17311 
        else:
17312 
          iprot.skip(ftype)
17313 
      else:
17314 
        iprot.skip(ftype)
17315 
      iprot.readFieldEnd()
17316 
    iprot.readStructEnd()
17317 
 
17318 
  def write(self, oprot):
17319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17321 
      return
17322 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
17323 
    if self.transactionId is not None:
17324 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
17325 
      oprot.writeI64(self.transactionId)
17326 
      oprot.writeFieldEnd()
17327 
    if self.category is not None:
17328 
      oprot.writeFieldBegin('category', TType.I32, 2)
17329 
      oprot.writeI32(self.category)
17330 
      oprot.writeFieldEnd()
17331 
    oprot.writeFieldStop()
17332 
    oprot.writeStructEnd()
17333 
 
17334 
  def validate(self):
17335 
    return
17336 
 
17337 
 
17338 
  def __repr__(self):
17339 
    L = ['%s=%r' % (key, value)
17340 
      for key, value in self.__dict__.iteritems()]
17341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17342 
 
17343 
  def __eq__(self, other):
17344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17345 
 
17346 
  def __ne__(self, other):
17347 
    return not (self == other)
17348 
 
17349 
class markTransactionAsProcessed_result:
17350 
 
17351 
  thrift_spec = (
17352 
  )
17353 
 
17354 
  def read(self, iprot):
17355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17357 
      return
17358 
    iprot.readStructBegin()
17359 
    while True:
17360 
      (fname, ftype, fid) = iprot.readFieldBegin()
17361 
      if ftype == TType.STOP:
17362 
        break
17363 
      else:
17364 
        iprot.skip(ftype)
17365 
      iprot.readFieldEnd()
17366 
    iprot.readStructEnd()
17367 
 
17368 
  def write(self, oprot):
17369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17371 
      return
17372 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
17373 
    oprot.writeFieldStop()
17374 
    oprot.writeStructEnd()
17375 
 
17376 
  def validate(self):
17377 
    return
17378 
 
17379 
 
17380 
  def __repr__(self):
17381 
    L = ['%s=%r' % (key, value)
17382 
      for key, value in self.__dict__.iteritems()]
17383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17384 
 
17385 
  def __eq__(self, other):
17386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17387 
 
17388 
  def __ne__(self, other):
17389 
    return not (self == other)
4018 chandransh 17390 
 
17391 
class getItemWiseRiskyOrdersCount_args:
17392 
 
17393 
  thrift_spec = (
17394 
  )
17395 
 
17396 
  def read(self, iprot):
17397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17399 
      return
17400 
    iprot.readStructBegin()
17401 
    while True:
17402 
      (fname, ftype, fid) = iprot.readFieldBegin()
17403 
      if ftype == TType.STOP:
17404 
        break
17405 
      else:
17406 
        iprot.skip(ftype)
17407 
      iprot.readFieldEnd()
17408 
    iprot.readStructEnd()
17409 
 
17410 
  def write(self, oprot):
17411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17413 
      return
17414 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
17415 
    oprot.writeFieldStop()
17416 
    oprot.writeStructEnd()
17417 
 
17418 
  def validate(self):
17419 
    return
17420 
 
17421 
 
17422 
  def __repr__(self):
17423 
    L = ['%s=%r' % (key, value)
17424 
      for key, value in self.__dict__.iteritems()]
17425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17426 
 
17427 
  def __eq__(self, other):
17428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17429 
 
17430 
  def __ne__(self, other):
17431 
    return not (self == other)
17432 
 
17433 
class getItemWiseRiskyOrdersCount_result:
17434 
  """
17435 
  Attributes:
17436 
   - success
17437 
  """
17438 
 
17439 
  thrift_spec = (
17440 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
17441 
  )
17442 
 
17443 
  def __init__(self, success=None,):
17444 
    self.success = success
17445 
 
17446 
  def read(self, iprot):
17447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17449 
      return
17450 
    iprot.readStructBegin()
17451 
    while True:
17452 
      (fname, ftype, fid) = iprot.readFieldBegin()
17453 
      if ftype == TType.STOP:
17454 
        break
17455 
      if fid == 0:
17456 
        if ftype == TType.MAP:
17457 
          self.success = {}
5031 varun.gupt 17458 
          (_ktype387, _vtype388, _size386 ) = iprot.readMapBegin()
17459 
          for _i390 in xrange(_size386):
17460 
            _key391 = iprot.readI64();
17461 
            _val392 = iprot.readI64();
17462 
            self.success[_key391] = _val392
4018 chandransh 17463 
          iprot.readMapEnd()
17464 
        else:
17465 
          iprot.skip(ftype)
17466 
      else:
17467 
        iprot.skip(ftype)
17468 
      iprot.readFieldEnd()
17469 
    iprot.readStructEnd()
17470 
 
17471 
  def write(self, oprot):
17472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17474 
      return
17475 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
17476 
    if self.success is not None:
17477 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17478 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5031 varun.gupt 17479 
      for kiter393,viter394 in self.success.items():
17480 
        oprot.writeI64(kiter393)
17481 
        oprot.writeI64(viter394)
4018 chandransh 17482 
      oprot.writeMapEnd()
17483 
      oprot.writeFieldEnd()
17484 
    oprot.writeFieldStop()
17485 
    oprot.writeStructEnd()
17486 
 
17487 
  def validate(self):
17488 
    return
17489 
 
17490 
 
17491 
  def __repr__(self):
17492 
    L = ['%s=%r' % (key, value)
17493 
      for key, value in self.__dict__.iteritems()]
17494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17495 
 
17496 
  def __eq__(self, other):
17497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17498 
 
17499 
  def __ne__(self, other):
17500 
    return not (self == other)
4247 rajveer 17501 
 
4295 varun.gupt 17502 
class getOrdersForItemIds_args:
17503 
  """
17504 
  Attributes:
17505 
   - itemIds
17506 
  """
17507 
 
17508 
  thrift_spec = (
17509 
    None, # 0
17510 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
17511 
  )
17512 
 
17513 
  def __init__(self, itemIds=None,):
17514 
    self.itemIds = itemIds
17515 
 
17516 
  def read(self, iprot):
17517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17519 
      return
17520 
    iprot.readStructBegin()
17521 
    while True:
17522 
      (fname, ftype, fid) = iprot.readFieldBegin()
17523 
      if ftype == TType.STOP:
17524 
        break
17525 
      if fid == 1:
17526 
        if ftype == TType.LIST:
17527 
          self.itemIds = []
5031 varun.gupt 17528 
          (_etype398, _size395) = iprot.readListBegin()
17529 
          for _i399 in xrange(_size395):
17530 
            _elem400 = iprot.readI64();
17531 
            self.itemIds.append(_elem400)
4295 varun.gupt 17532 
          iprot.readListEnd()
17533 
        else:
17534 
          iprot.skip(ftype)
17535 
      else:
17536 
        iprot.skip(ftype)
17537 
      iprot.readFieldEnd()
17538 
    iprot.readStructEnd()
17539 
 
17540 
  def write(self, oprot):
17541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17543 
      return
17544 
    oprot.writeStructBegin('getOrdersForItemIds_args')
17545 
    if self.itemIds is not None:
17546 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
17547 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5031 varun.gupt 17548 
      for iter401 in self.itemIds:
17549 
        oprot.writeI64(iter401)
4295 varun.gupt 17550 
      oprot.writeListEnd()
17551 
      oprot.writeFieldEnd()
17552 
    oprot.writeFieldStop()
17553 
    oprot.writeStructEnd()
17554 
 
17555 
  def validate(self):
17556 
    return
17557 
 
17558 
 
17559 
  def __repr__(self):
17560 
    L = ['%s=%r' % (key, value)
17561 
      for key, value in self.__dict__.iteritems()]
17562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17563 
 
17564 
  def __eq__(self, other):
17565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17566 
 
17567 
  def __ne__(self, other):
17568 
    return not (self == other)
17569 
 
17570 
class getOrdersForItemIds_result:
17571 
  """
17572 
  Attributes:
17573 
   - success
17574 
  """
17575 
 
17576 
  thrift_spec = (
17577 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17578 
  )
17579 
 
17580 
  def __init__(self, success=None,):
17581 
    self.success = success
17582 
 
17583 
  def read(self, iprot):
17584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17586 
      return
17587 
    iprot.readStructBegin()
17588 
    while True:
17589 
      (fname, ftype, fid) = iprot.readFieldBegin()
17590 
      if ftype == TType.STOP:
17591 
        break
17592 
      if fid == 0:
17593 
        if ftype == TType.LIST:
17594 
          self.success = []
5031 varun.gupt 17595 
          (_etype405, _size402) = iprot.readListBegin()
17596 
          for _i406 in xrange(_size402):
17597 
            _elem407 = Order()
17598 
            _elem407.read(iprot)
17599 
            self.success.append(_elem407)
4295 varun.gupt 17600 
          iprot.readListEnd()
17601 
        else:
17602 
          iprot.skip(ftype)
17603 
      else:
17604 
        iprot.skip(ftype)
17605 
      iprot.readFieldEnd()
17606 
    iprot.readStructEnd()
17607 
 
17608 
  def write(self, oprot):
17609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17611 
      return
17612 
    oprot.writeStructBegin('getOrdersForItemIds_result')
17613 
    if self.success is not None:
17614 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17615 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 17616 
      for iter408 in self.success:
17617 
        iter408.write(oprot)
4295 varun.gupt 17618 
      oprot.writeListEnd()
17619 
      oprot.writeFieldEnd()
17620 
    oprot.writeFieldStop()
17621 
    oprot.writeStructEnd()
17622 
 
17623 
  def validate(self):
17624 
    return
17625 
 
17626 
 
17627 
  def __repr__(self):
17628 
    L = ['%s=%r' % (key, value)
17629 
      for key, value in self.__dict__.iteritems()]
17630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17631 
 
17632 
  def __eq__(self, other):
17633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17634 
 
17635 
  def __ne__(self, other):
17636 
    return not (self == other)
17637 
 
4247 rajveer 17638 
class markOrderCancellationRequestReceived_args:
17639 
  """
17640 
  Attributes:
17641 
   - orderId
17642 
  """
17643 
 
17644 
  thrift_spec = (
17645 
    None, # 0
17646 
    (1, TType.I64, 'orderId', None, None, ), # 1
17647 
  )
17648 
 
17649 
  def __init__(self, orderId=None,):
17650 
    self.orderId = orderId
17651 
 
17652 
  def read(self, iprot):
17653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17655 
      return
17656 
    iprot.readStructBegin()
17657 
    while True:
17658 
      (fname, ftype, fid) = iprot.readFieldBegin()
17659 
      if ftype == TType.STOP:
17660 
        break
17661 
      if fid == 1:
17662 
        if ftype == TType.I64:
17663 
          self.orderId = iprot.readI64();
17664 
        else:
17665 
          iprot.skip(ftype)
17666 
      else:
17667 
        iprot.skip(ftype)
17668 
      iprot.readFieldEnd()
17669 
    iprot.readStructEnd()
17670 
 
17671 
  def write(self, oprot):
17672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17674 
      return
17675 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
17676 
    if self.orderId is not None:
17677 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17678 
      oprot.writeI64(self.orderId)
17679 
      oprot.writeFieldEnd()
17680 
    oprot.writeFieldStop()
17681 
    oprot.writeStructEnd()
17682 
 
17683 
  def validate(self):
17684 
    return
17685 
 
17686 
 
17687 
  def __repr__(self):
17688 
    L = ['%s=%r' % (key, value)
17689 
      for key, value in self.__dict__.iteritems()]
17690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17691 
 
17692 
  def __eq__(self, other):
17693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17694 
 
17695 
  def __ne__(self, other):
17696 
    return not (self == other)
17697 
 
17698 
class markOrderCancellationRequestReceived_result:
17699 
  """
17700 
  Attributes:
17701 
   - ex
17702 
  """
17703 
 
17704 
  thrift_spec = (
17705 
    None, # 0
17706 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17707 
  )
17708 
 
17709 
  def __init__(self, ex=None,):
17710 
    self.ex = ex
17711 
 
17712 
  def read(self, iprot):
17713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17715 
      return
17716 
    iprot.readStructBegin()
17717 
    while True:
17718 
      (fname, ftype, fid) = iprot.readFieldBegin()
17719 
      if ftype == TType.STOP:
17720 
        break
17721 
      if fid == 1:
17722 
        if ftype == TType.STRUCT:
17723 
          self.ex = TransactionServiceException()
17724 
          self.ex.read(iprot)
17725 
        else:
17726 
          iprot.skip(ftype)
17727 
      else:
17728 
        iprot.skip(ftype)
17729 
      iprot.readFieldEnd()
17730 
    iprot.readStructEnd()
17731 
 
17732 
  def write(self, oprot):
17733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17735 
      return
17736 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
17737 
    if self.ex is not None:
17738 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17739 
      self.ex.write(oprot)
17740 
      oprot.writeFieldEnd()
17741 
    oprot.writeFieldStop()
17742 
    oprot.writeStructEnd()
17743 
 
17744 
  def validate(self):
17745 
    return
17746 
 
17747 
 
17748 
  def __repr__(self):
17749 
    L = ['%s=%r' % (key, value)
17750 
      for key, value in self.__dict__.iteritems()]
17751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17752 
 
17753 
  def __eq__(self, other):
17754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17755 
 
17756 
  def __ne__(self, other):
17757 
    return not (self == other)
17758 
 
17759 
class markOrderCancellationRequestConfirmed_args:
17760 
  """
17761 
  Attributes:
17762 
   - orderId
17763 
  """
17764 
 
17765 
  thrift_spec = (
17766 
    None, # 0
17767 
    (1, TType.I64, 'orderId', None, None, ), # 1
17768 
  )
17769 
 
17770 
  def __init__(self, orderId=None,):
17771 
    self.orderId = orderId
17772 
 
17773 
  def read(self, iprot):
17774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17776 
      return
17777 
    iprot.readStructBegin()
17778 
    while True:
17779 
      (fname, ftype, fid) = iprot.readFieldBegin()
17780 
      if ftype == TType.STOP:
17781 
        break
17782 
      if fid == 1:
17783 
        if ftype == TType.I64:
17784 
          self.orderId = iprot.readI64();
17785 
        else:
17786 
          iprot.skip(ftype)
17787 
      else:
17788 
        iprot.skip(ftype)
17789 
      iprot.readFieldEnd()
17790 
    iprot.readStructEnd()
17791 
 
17792 
  def write(self, oprot):
17793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17795 
      return
17796 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
17797 
    if self.orderId is not None:
17798 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17799 
      oprot.writeI64(self.orderId)
17800 
      oprot.writeFieldEnd()
17801 
    oprot.writeFieldStop()
17802 
    oprot.writeStructEnd()
17803 
 
17804 
  def validate(self):
17805 
    return
17806 
 
17807 
 
17808 
  def __repr__(self):
17809 
    L = ['%s=%r' % (key, value)
17810 
      for key, value in self.__dict__.iteritems()]
17811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17812 
 
17813 
  def __eq__(self, other):
17814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17815 
 
17816 
  def __ne__(self, other):
17817 
    return not (self == other)
17818 
 
17819 
class markOrderCancellationRequestConfirmed_result:
17820 
  """
17821 
  Attributes:
17822 
   - ex
17823 
  """
17824 
 
17825 
  thrift_spec = (
17826 
    None, # 0
17827 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17828 
  )
17829 
 
17830 
  def __init__(self, ex=None,):
17831 
    self.ex = ex
17832 
 
17833 
  def read(self, iprot):
17834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17836 
      return
17837 
    iprot.readStructBegin()
17838 
    while True:
17839 
      (fname, ftype, fid) = iprot.readFieldBegin()
17840 
      if ftype == TType.STOP:
17841 
        break
17842 
      if fid == 1:
17843 
        if ftype == TType.STRUCT:
17844 
          self.ex = TransactionServiceException()
17845 
          self.ex.read(iprot)
17846 
        else:
17847 
          iprot.skip(ftype)
17848 
      else:
17849 
        iprot.skip(ftype)
17850 
      iprot.readFieldEnd()
17851 
    iprot.readStructEnd()
17852 
 
17853 
  def write(self, oprot):
17854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17856 
      return
17857 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
17858 
    if self.ex is not None:
17859 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17860 
      self.ex.write(oprot)
17861 
      oprot.writeFieldEnd()
17862 
    oprot.writeFieldStop()
17863 
    oprot.writeStructEnd()
17864 
 
17865 
  def validate(self):
17866 
    return
17867 
 
17868 
 
17869 
  def __repr__(self):
17870 
    L = ['%s=%r' % (key, value)
17871 
      for key, value in self.__dict__.iteritems()]
17872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17873 
 
17874 
  def __eq__(self, other):
17875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17876 
 
17877 
  def __ne__(self, other):
17878 
    return not (self == other)
17879 
 
17880 
class markOrderCancellationRequestDenied_args:
17881 
  """
17882 
  Attributes:
17883 
   - orderId
17884 
  """
17885 
 
17886 
  thrift_spec = (
17887 
    None, # 0
17888 
    (1, TType.I64, 'orderId', None, None, ), # 1
17889 
  )
17890 
 
17891 
  def __init__(self, orderId=None,):
17892 
    self.orderId = orderId
17893 
 
17894 
  def read(self, iprot):
17895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17897 
      return
17898 
    iprot.readStructBegin()
17899 
    while True:
17900 
      (fname, ftype, fid) = iprot.readFieldBegin()
17901 
      if ftype == TType.STOP:
17902 
        break
17903 
      if fid == 1:
17904 
        if ftype == TType.I64:
17905 
          self.orderId = iprot.readI64();
17906 
        else:
17907 
          iprot.skip(ftype)
17908 
      else:
17909 
        iprot.skip(ftype)
17910 
      iprot.readFieldEnd()
17911 
    iprot.readStructEnd()
17912 
 
17913 
  def write(self, oprot):
17914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17916 
      return
17917 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
17918 
    if self.orderId is not None:
17919 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17920 
      oprot.writeI64(self.orderId)
17921 
      oprot.writeFieldEnd()
17922 
    oprot.writeFieldStop()
17923 
    oprot.writeStructEnd()
17924 
 
17925 
  def validate(self):
17926 
    return
17927 
 
17928 
 
17929 
  def __repr__(self):
17930 
    L = ['%s=%r' % (key, value)
17931 
      for key, value in self.__dict__.iteritems()]
17932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17933 
 
17934 
  def __eq__(self, other):
17935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17936 
 
17937 
  def __ne__(self, other):
17938 
    return not (self == other)
17939 
 
17940 
class markOrderCancellationRequestDenied_result:
17941 
  """
17942 
  Attributes:
17943 
   - ex
17944 
  """
17945 
 
17946 
  thrift_spec = (
17947 
    None, # 0
17948 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17949 
  )
17950 
 
17951 
  def __init__(self, ex=None,):
17952 
    self.ex = ex
17953 
 
17954 
  def read(self, iprot):
17955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17957 
      return
17958 
    iprot.readStructBegin()
17959 
    while True:
17960 
      (fname, ftype, fid) = iprot.readFieldBegin()
17961 
      if ftype == TType.STOP:
17962 
        break
17963 
      if fid == 1:
17964 
        if ftype == TType.STRUCT:
17965 
          self.ex = TransactionServiceException()
17966 
          self.ex.read(iprot)
17967 
        else:
17968 
          iprot.skip(ftype)
17969 
      else:
17970 
        iprot.skip(ftype)
17971 
      iprot.readFieldEnd()
17972 
    iprot.readStructEnd()
17973 
 
17974 
  def write(self, oprot):
17975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17977 
      return
17978 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
17979 
    if self.ex is not None:
17980 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17981 
      self.ex.write(oprot)
17982 
      oprot.writeFieldEnd()
17983 
    oprot.writeFieldStop()
17984 
    oprot.writeStructEnd()
17985 
 
17986 
  def validate(self):
17987 
    return
17988 
 
17989 
 
17990 
  def __repr__(self):
17991 
    L = ['%s=%r' % (key, value)
17992 
      for key, value in self.__dict__.iteritems()]
17993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17994 
 
17995 
  def __eq__(self, other):
17996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17997 
 
17998 
  def __ne__(self, other):
17999 
    return not (self == other)
18000 
 
4258 rajveer 18001 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 18002 
  """
18003 
  Attributes:
4258 rajveer 18004 
   - transactionId
4247 rajveer 18005 
  """
18006 
 
18007 
  thrift_spec = (
18008 
    None, # 0
4258 rajveer 18009 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 18010 
  )
18011 
 
4258 rajveer 18012 
  def __init__(self, transactionId=None,):
18013 
    self.transactionId = transactionId
4247 rajveer 18014 
 
18015 
  def read(self, iprot):
18016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18018 
      return
18019 
    iprot.readStructBegin()
18020 
    while True:
18021 
      (fname, ftype, fid) = iprot.readFieldBegin()
18022 
      if ftype == TType.STOP:
18023 
        break
18024 
      if fid == 1:
18025 
        if ftype == TType.I64:
4258 rajveer 18026 
          self.transactionId = iprot.readI64();
4247 rajveer 18027 
        else:
18028 
          iprot.skip(ftype)
18029 
      else:
18030 
        iprot.skip(ftype)
18031 
      iprot.readFieldEnd()
18032 
    iprot.readStructEnd()
18033 
 
18034 
  def write(self, oprot):
18035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18037 
      return
4258 rajveer 18038 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
18039 
    if self.transactionId is not None:
18040 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18041 
      oprot.writeI64(self.transactionId)
4247 rajveer 18042 
      oprot.writeFieldEnd()
18043 
    oprot.writeFieldStop()
18044 
    oprot.writeStructEnd()
18045 
 
18046 
  def validate(self):
18047 
    return
18048 
 
18049 
 
18050 
  def __repr__(self):
18051 
    L = ['%s=%r' % (key, value)
18052 
      for key, value in self.__dict__.iteritems()]
18053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18054 
 
18055 
  def __eq__(self, other):
18056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18057 
 
18058 
  def __ne__(self, other):
18059 
    return not (self == other)
18060 
 
4258 rajveer 18061 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 18062 
  """
18063 
  Attributes:
18064 
   - ex
18065 
  """
18066 
 
18067 
  thrift_spec = (
18068 
    None, # 0
18069 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18070 
  )
18071 
 
18072 
  def __init__(self, ex=None,):
18073 
    self.ex = ex
18074 
 
18075 
  def read(self, iprot):
18076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18078 
      return
18079 
    iprot.readStructBegin()
18080 
    while True:
18081 
      (fname, ftype, fid) = iprot.readFieldBegin()
18082 
      if ftype == TType.STOP:
18083 
        break
18084 
      if fid == 1:
18085 
        if ftype == TType.STRUCT:
18086 
          self.ex = TransactionServiceException()
18087 
          self.ex.read(iprot)
18088 
        else:
18089 
          iprot.skip(ftype)
18090 
      else:
18091 
        iprot.skip(ftype)
18092 
      iprot.readFieldEnd()
18093 
    iprot.readStructEnd()
18094 
 
18095 
  def write(self, oprot):
18096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18098 
      return
4258 rajveer 18099 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 18100 
    if self.ex is not None:
18101 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18102 
      self.ex.write(oprot)
18103 
      oprot.writeFieldEnd()
18104 
    oprot.writeFieldStop()
18105 
    oprot.writeStructEnd()
18106 
 
18107 
  def validate(self):
18108 
    return
18109 
 
18110 
 
18111 
  def __repr__(self):
18112 
    L = ['%s=%r' % (key, value)
18113 
      for key, value in self.__dict__.iteritems()]
18114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18115 
 
18116 
  def __eq__(self, other):
18117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18118 
 
18119 
  def __ne__(self, other):
18120 
    return not (self == other)
4259 anupam.sin 18121 
 
18122 
class refundTransaction_args:
18123 
  """
18124 
  Attributes:
18125 
   - transactionId
18126 
   - refundedBy
18127 
   - reason
18128 
  """
18129 
 
18130 
  thrift_spec = (
18131 
    None, # 0
18132 
    (1, TType.I64, 'transactionId', None, None, ), # 1
18133 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18134 
    (3, TType.STRING, 'reason', None, None, ), # 3
18135 
  )
18136 
 
18137 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
18138 
    self.transactionId = transactionId
18139 
    self.refundedBy = refundedBy
18140 
    self.reason = reason
18141 
 
18142 
  def read(self, iprot):
18143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18145 
      return
18146 
    iprot.readStructBegin()
18147 
    while True:
18148 
      (fname, ftype, fid) = iprot.readFieldBegin()
18149 
      if ftype == TType.STOP:
18150 
        break
18151 
      if fid == 1:
18152 
        if ftype == TType.I64:
18153 
          self.transactionId = iprot.readI64();
18154 
        else:
18155 
          iprot.skip(ftype)
18156 
      elif fid == 2:
18157 
        if ftype == TType.STRING:
18158 
          self.refundedBy = iprot.readString();
18159 
        else:
18160 
          iprot.skip(ftype)
18161 
      elif fid == 3:
18162 
        if ftype == TType.STRING:
18163 
          self.reason = iprot.readString();
18164 
        else:
18165 
          iprot.skip(ftype)
18166 
      else:
18167 
        iprot.skip(ftype)
18168 
      iprot.readFieldEnd()
18169 
    iprot.readStructEnd()
18170 
 
18171 
  def write(self, oprot):
18172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18174 
      return
18175 
    oprot.writeStructBegin('refundTransaction_args')
18176 
    if self.transactionId is not None:
18177 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18178 
      oprot.writeI64(self.transactionId)
18179 
      oprot.writeFieldEnd()
18180 
    if self.refundedBy is not None:
18181 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18182 
      oprot.writeString(self.refundedBy)
18183 
      oprot.writeFieldEnd()
18184 
    if self.reason is not None:
18185 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18186 
      oprot.writeString(self.reason)
18187 
      oprot.writeFieldEnd()
18188 
    oprot.writeFieldStop()
18189 
    oprot.writeStructEnd()
18190 
 
18191 
  def validate(self):
18192 
    return
18193 
 
18194 
 
18195 
  def __repr__(self):
18196 
    L = ['%s=%r' % (key, value)
18197 
      for key, value in self.__dict__.iteritems()]
18198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18199 
 
18200 
  def __eq__(self, other):
18201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18202 
 
18203 
  def __ne__(self, other):
18204 
    return not (self == other)
18205 
 
18206 
class refundTransaction_result:
18207 
  """
18208 
  Attributes:
18209 
   - ex
18210 
  """
18211 
 
18212 
  thrift_spec = (
18213 
    None, # 0
18214 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18215 
  )
18216 
 
18217 
  def __init__(self, ex=None,):
18218 
    self.ex = ex
18219 
 
18220 
  def read(self, iprot):
18221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18223 
      return
18224 
    iprot.readStructBegin()
18225 
    while True:
18226 
      (fname, ftype, fid) = iprot.readFieldBegin()
18227 
      if ftype == TType.STOP:
18228 
        break
18229 
      if fid == 1:
18230 
        if ftype == TType.STRUCT:
18231 
          self.ex = TransactionServiceException()
18232 
          self.ex.read(iprot)
18233 
        else:
18234 
          iprot.skip(ftype)
18235 
      else:
18236 
        iprot.skip(ftype)
18237 
      iprot.readFieldEnd()
18238 
    iprot.readStructEnd()
18239 
 
18240 
  def write(self, oprot):
18241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18243 
      return
18244 
    oprot.writeStructBegin('refundTransaction_result')
18245 
    if self.ex is not None:
18246 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18247 
      self.ex.write(oprot)
18248 
      oprot.writeFieldEnd()
18249 
    oprot.writeFieldStop()
18250 
    oprot.writeStructEnd()
18251 
 
18252 
  def validate(self):
18253 
    return
18254 
 
18255 
 
18256 
  def __repr__(self):
18257 
    L = ['%s=%r' % (key, value)
18258 
      for key, value in self.__dict__.iteritems()]
18259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18260 
 
18261 
  def __eq__(self, other):
18262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18263 
 
18264 
  def __ne__(self, other):
18265 
    return not (self == other)
4285 rajveer 18266 
 
4324 mandeep.dh 18267 
class updateShipmentAddress_args:
18268 
  """
18269 
  Attributes:
18270 
   - orderId
18271 
   - addressId
18272 
  """
18273 
 
18274 
  thrift_spec = (
18275 
    None, # 0
18276 
    (1, TType.I64, 'orderId', None, None, ), # 1
18277 
    (2, TType.I64, 'addressId', None, None, ), # 2
18278 
  )
18279 
 
18280 
  def __init__(self, orderId=None, addressId=None,):
18281 
    self.orderId = orderId
18282 
    self.addressId = addressId
18283 
 
18284 
  def read(self, iprot):
18285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18287 
      return
18288 
    iprot.readStructBegin()
18289 
    while True:
18290 
      (fname, ftype, fid) = iprot.readFieldBegin()
18291 
      if ftype == TType.STOP:
18292 
        break
18293 
      if fid == 1:
18294 
        if ftype == TType.I64:
18295 
          self.orderId = iprot.readI64();
18296 
        else:
18297 
          iprot.skip(ftype)
18298 
      elif fid == 2:
18299 
        if ftype == TType.I64:
18300 
          self.addressId = iprot.readI64();
18301 
        else:
18302 
          iprot.skip(ftype)
18303 
      else:
18304 
        iprot.skip(ftype)
18305 
      iprot.readFieldEnd()
18306 
    iprot.readStructEnd()
18307 
 
18308 
  def write(self, oprot):
18309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18311 
      return
18312 
    oprot.writeStructBegin('updateShipmentAddress_args')
18313 
    if self.orderId is not None:
18314 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18315 
      oprot.writeI64(self.orderId)
18316 
      oprot.writeFieldEnd()
18317 
    if self.addressId is not None:
18318 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
18319 
      oprot.writeI64(self.addressId)
18320 
      oprot.writeFieldEnd()
18321 
    oprot.writeFieldStop()
18322 
    oprot.writeStructEnd()
18323 
 
18324 
  def validate(self):
18325 
    return
18326 
 
18327 
 
18328 
  def __repr__(self):
18329 
    L = ['%s=%r' % (key, value)
18330 
      for key, value in self.__dict__.iteritems()]
18331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18332 
 
18333 
  def __eq__(self, other):
18334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18335 
 
18336 
  def __ne__(self, other):
18337 
    return not (self == other)
18338 
 
18339 
class updateShipmentAddress_result:
18340 
  """
18341 
  Attributes:
18342 
   - ex
18343 
  """
18344 
 
18345 
  thrift_spec = (
18346 
    None, # 0
18347 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18348 
  )
18349 
 
18350 
  def __init__(self, ex=None,):
18351 
    self.ex = ex
18352 
 
18353 
  def read(self, iprot):
18354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18356 
      return
18357 
    iprot.readStructBegin()
18358 
    while True:
18359 
      (fname, ftype, fid) = iprot.readFieldBegin()
18360 
      if ftype == TType.STOP:
18361 
        break
18362 
      if fid == 1:
18363 
        if ftype == TType.STRUCT:
18364 
          self.ex = TransactionServiceException()
18365 
          self.ex.read(iprot)
18366 
        else:
18367 
          iprot.skip(ftype)
18368 
      else:
18369 
        iprot.skip(ftype)
18370 
      iprot.readFieldEnd()
18371 
    iprot.readStructEnd()
18372 
 
18373 
  def write(self, oprot):
18374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18376 
      return
18377 
    oprot.writeStructBegin('updateShipmentAddress_result')
18378 
    if self.ex is not None:
18379 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18380 
      self.ex.write(oprot)
18381 
      oprot.writeFieldEnd()
18382 
    oprot.writeFieldStop()
18383 
    oprot.writeStructEnd()
18384 
 
18385 
  def validate(self):
18386 
    return
18387 
 
18388 
 
18389 
  def __repr__(self):
18390 
    L = ['%s=%r' % (key, value)
18391 
      for key, value in self.__dict__.iteritems()]
18392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18393 
 
18394 
  def __eq__(self, other):
18395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18396 
 
18397 
  def __ne__(self, other):
18398 
    return not (self == other)
18399 
 
4285 rajveer 18400 
class acceptOrdersForItemId_args:
18401 
  """
18402 
  Attributes:
18403 
   - itemId
18404 
   - inventory
18405 
  """
18406 
 
18407 
  thrift_spec = (
18408 
    None, # 0
18409 
    (1, TType.I64, 'itemId', None, None, ), # 1
18410 
    (2, TType.I64, 'inventory', None, None, ), # 2
18411 
  )
18412 
 
18413 
  def __init__(self, itemId=None, inventory=None,):
18414 
    self.itemId = itemId
18415 
    self.inventory = inventory
18416 
 
18417 
  def read(self, iprot):
18418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18420 
      return
18421 
    iprot.readStructBegin()
18422 
    while True:
18423 
      (fname, ftype, fid) = iprot.readFieldBegin()
18424 
      if ftype == TType.STOP:
18425 
        break
18426 
      if fid == 1:
18427 
        if ftype == TType.I64:
18428 
          self.itemId = iprot.readI64();
18429 
        else:
18430 
          iprot.skip(ftype)
18431 
      elif fid == 2:
18432 
        if ftype == TType.I64:
18433 
          self.inventory = iprot.readI64();
18434 
        else:
18435 
          iprot.skip(ftype)
18436 
      else:
18437 
        iprot.skip(ftype)
18438 
      iprot.readFieldEnd()
18439 
    iprot.readStructEnd()
18440 
 
18441 
  def write(self, oprot):
18442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18444 
      return
18445 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
18446 
    if self.itemId is not None:
18447 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18448 
      oprot.writeI64(self.itemId)
18449 
      oprot.writeFieldEnd()
18450 
    if self.inventory is not None:
18451 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
18452 
      oprot.writeI64(self.inventory)
18453 
      oprot.writeFieldEnd()
18454 
    oprot.writeFieldStop()
18455 
    oprot.writeStructEnd()
18456 
 
18457 
  def validate(self):
18458 
    return
18459 
 
18460 
 
18461 
  def __repr__(self):
18462 
    L = ['%s=%r' % (key, value)
18463 
      for key, value in self.__dict__.iteritems()]
18464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18465 
 
18466 
  def __eq__(self, other):
18467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18468 
 
18469 
  def __ne__(self, other):
18470 
    return not (self == other)
18471 
 
18472 
class acceptOrdersForItemId_result:
18473 
  """
18474 
  Attributes:
18475 
   - success
18476 
   - ex
18477 
  """
18478 
 
18479 
  thrift_spec = (
18480 
    (0, TType.BOOL, 'success', None, None, ), # 0
18481 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18482 
  )
18483 
 
18484 
  def __init__(self, success=None, ex=None,):
18485 
    self.success = success
18486 
    self.ex = ex
18487 
 
18488 
  def read(self, iprot):
18489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18491 
      return
18492 
    iprot.readStructBegin()
18493 
    while True:
18494 
      (fname, ftype, fid) = iprot.readFieldBegin()
18495 
      if ftype == TType.STOP:
18496 
        break
18497 
      if fid == 0:
18498 
        if ftype == TType.BOOL:
18499 
          self.success = iprot.readBool();
18500 
        else:
18501 
          iprot.skip(ftype)
18502 
      elif fid == 1:
18503 
        if ftype == TType.STRUCT:
18504 
          self.ex = TransactionServiceException()
18505 
          self.ex.read(iprot)
18506 
        else:
18507 
          iprot.skip(ftype)
18508 
      else:
18509 
        iprot.skip(ftype)
18510 
      iprot.readFieldEnd()
18511 
    iprot.readStructEnd()
18512 
 
18513 
  def write(self, oprot):
18514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18516 
      return
18517 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
18518 
    if self.success is not None:
18519 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18520 
      oprot.writeBool(self.success)
18521 
      oprot.writeFieldEnd()
18522 
    if self.ex is not None:
18523 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18524 
      self.ex.write(oprot)
18525 
      oprot.writeFieldEnd()
18526 
    oprot.writeFieldStop()
18527 
    oprot.writeStructEnd()
18528 
 
18529 
  def validate(self):
18530 
    return
18531 
 
18532 
 
18533 
  def __repr__(self):
18534 
    L = ['%s=%r' % (key, value)
18535 
      for key, value in self.__dict__.iteritems()]
18536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18537 
 
18538 
  def __eq__(self, other):
18539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18540 
 
18541 
  def __ne__(self, other):
18542 
    return not (self == other)
4303 rajveer 18543 
 
18544 
class markOrdersAsPORaised_args:
18545 
  """
18546 
  Attributes:
18547 
   - vendorId
18548 
   - itemId
18549 
   - quantity
18550 
   - estimate
4369 rajveer 18551 
   - isReminder
4303 rajveer 18552 
  """
18553 
 
18554 
  thrift_spec = (
18555 
    None, # 0
18556 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18557 
    (2, TType.I64, 'itemId', None, None, ), # 2
18558 
    (3, TType.I64, 'quantity', None, None, ), # 3
18559 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18560 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18561 
  )
18562 
 
4369 rajveer 18563 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18564 
    self.vendorId = vendorId
18565 
    self.itemId = itemId
18566 
    self.quantity = quantity
18567 
    self.estimate = estimate
4369 rajveer 18568 
    self.isReminder = isReminder
4303 rajveer 18569 
 
18570 
  def read(self, iprot):
18571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18573 
      return
18574 
    iprot.readStructBegin()
18575 
    while True:
18576 
      (fname, ftype, fid) = iprot.readFieldBegin()
18577 
      if ftype == TType.STOP:
18578 
        break
18579 
      if fid == 1:
18580 
        if ftype == TType.I64:
18581 
          self.vendorId = iprot.readI64();
18582 
        else:
18583 
          iprot.skip(ftype)
18584 
      elif fid == 2:
18585 
        if ftype == TType.I64:
18586 
          self.itemId = iprot.readI64();
18587 
        else:
18588 
          iprot.skip(ftype)
18589 
      elif fid == 3:
18590 
        if ftype == TType.I64:
18591 
          self.quantity = iprot.readI64();
18592 
        else:
18593 
          iprot.skip(ftype)
18594 
      elif fid == 4:
18595 
        if ftype == TType.I64:
18596 
          self.estimate = iprot.readI64();
18597 
        else:
18598 
          iprot.skip(ftype)
4369 rajveer 18599 
      elif fid == 5:
18600 
        if ftype == TType.BOOL:
18601 
          self.isReminder = iprot.readBool();
18602 
        else:
18603 
          iprot.skip(ftype)
4303 rajveer 18604 
      else:
18605 
        iprot.skip(ftype)
18606 
      iprot.readFieldEnd()
18607 
    iprot.readStructEnd()
18608 
 
18609 
  def write(self, oprot):
18610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18612 
      return
18613 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
18614 
    if self.vendorId is not None:
18615 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18616 
      oprot.writeI64(self.vendorId)
18617 
      oprot.writeFieldEnd()
18618 
    if self.itemId is not None:
18619 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18620 
      oprot.writeI64(self.itemId)
18621 
      oprot.writeFieldEnd()
18622 
    if self.quantity is not None:
18623 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18624 
      oprot.writeI64(self.quantity)
18625 
      oprot.writeFieldEnd()
18626 
    if self.estimate is not None:
18627 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18628 
      oprot.writeI64(self.estimate)
18629 
      oprot.writeFieldEnd()
4369 rajveer 18630 
    if self.isReminder is not None:
18631 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18632 
      oprot.writeBool(self.isReminder)
18633 
      oprot.writeFieldEnd()
4303 rajveer 18634 
    oprot.writeFieldStop()
18635 
    oprot.writeStructEnd()
18636 
 
18637 
  def validate(self):
18638 
    return
18639 
 
18640 
 
18641 
  def __repr__(self):
18642 
    L = ['%s=%r' % (key, value)
18643 
      for key, value in self.__dict__.iteritems()]
18644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18645 
 
18646 
  def __eq__(self, other):
18647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18648 
 
18649 
  def __ne__(self, other):
18650 
    return not (self == other)
18651 
 
18652 
class markOrdersAsPORaised_result:
18653 
  """
18654 
  Attributes:
18655 
   - ex
18656 
  """
18657 
 
18658 
  thrift_spec = (
18659 
    None, # 0
18660 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18661 
  )
18662 
 
18663 
  def __init__(self, ex=None,):
18664 
    self.ex = ex
18665 
 
18666 
  def read(self, iprot):
18667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18669 
      return
18670 
    iprot.readStructBegin()
18671 
    while True:
18672 
      (fname, ftype, fid) = iprot.readFieldBegin()
18673 
      if ftype == TType.STOP:
18674 
        break
18675 
      if fid == 1:
18676 
        if ftype == TType.STRUCT:
18677 
          self.ex = TransactionServiceException()
18678 
          self.ex.read(iprot)
18679 
        else:
18680 
          iprot.skip(ftype)
18681 
      else:
18682 
        iprot.skip(ftype)
18683 
      iprot.readFieldEnd()
18684 
    iprot.readStructEnd()
18685 
 
18686 
  def write(self, oprot):
18687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18689 
      return
18690 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
18691 
    if self.ex is not None:
18692 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18693 
      self.ex.write(oprot)
18694 
      oprot.writeFieldEnd()
18695 
    oprot.writeFieldStop()
18696 
    oprot.writeStructEnd()
18697 
 
18698 
  def validate(self):
18699 
    return
18700 
 
18701 
 
18702 
  def __repr__(self):
18703 
    L = ['%s=%r' % (key, value)
18704 
      for key, value in self.__dict__.iteritems()]
18705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18706 
 
18707 
  def __eq__(self, other):
18708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18709 
 
18710 
  def __ne__(self, other):
18711 
    return not (self == other)
18712 
 
18713 
class markOrdersAsReversalInitiated_args:
18714 
  """
18715 
  Attributes:
18716 
   - vendorId
18717 
   - itemId
18718 
   - quantity
18719 
   - estimate
4369 rajveer 18720 
   - isReminder
4303 rajveer 18721 
  """
18722 
 
18723 
  thrift_spec = (
18724 
    None, # 0
18725 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18726 
    (2, TType.I64, 'itemId', None, None, ), # 2
18727 
    (3, TType.I64, 'quantity', None, None, ), # 3
18728 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18729 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18730 
  )
18731 
 
4369 rajveer 18732 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18733 
    self.vendorId = vendorId
18734 
    self.itemId = itemId
18735 
    self.quantity = quantity
18736 
    self.estimate = estimate
4369 rajveer 18737 
    self.isReminder = isReminder
4303 rajveer 18738 
 
18739 
  def read(self, iprot):
18740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18742 
      return
18743 
    iprot.readStructBegin()
18744 
    while True:
18745 
      (fname, ftype, fid) = iprot.readFieldBegin()
18746 
      if ftype == TType.STOP:
18747 
        break
18748 
      if fid == 1:
18749 
        if ftype == TType.I64:
18750 
          self.vendorId = iprot.readI64();
18751 
        else:
18752 
          iprot.skip(ftype)
18753 
      elif fid == 2:
18754 
        if ftype == TType.I64:
18755 
          self.itemId = iprot.readI64();
18756 
        else:
18757 
          iprot.skip(ftype)
18758 
      elif fid == 3:
18759 
        if ftype == TType.I64:
18760 
          self.quantity = iprot.readI64();
18761 
        else:
18762 
          iprot.skip(ftype)
18763 
      elif fid == 4:
18764 
        if ftype == TType.I64:
18765 
          self.estimate = iprot.readI64();
18766 
        else:
18767 
          iprot.skip(ftype)
4369 rajveer 18768 
      elif fid == 5:
18769 
        if ftype == TType.BOOL:
18770 
          self.isReminder = iprot.readBool();
18771 
        else:
18772 
          iprot.skip(ftype)
4303 rajveer 18773 
      else:
18774 
        iprot.skip(ftype)
18775 
      iprot.readFieldEnd()
18776 
    iprot.readStructEnd()
18777 
 
18778 
  def write(self, oprot):
18779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18781 
      return
18782 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
18783 
    if self.vendorId is not None:
18784 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18785 
      oprot.writeI64(self.vendorId)
18786 
      oprot.writeFieldEnd()
18787 
    if self.itemId is not None:
18788 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18789 
      oprot.writeI64(self.itemId)
18790 
      oprot.writeFieldEnd()
18791 
    if self.quantity is not None:
18792 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18793 
      oprot.writeI64(self.quantity)
18794 
      oprot.writeFieldEnd()
18795 
    if self.estimate is not None:
18796 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18797 
      oprot.writeI64(self.estimate)
18798 
      oprot.writeFieldEnd()
4369 rajveer 18799 
    if self.isReminder is not None:
18800 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18801 
      oprot.writeBool(self.isReminder)
18802 
      oprot.writeFieldEnd()
4303 rajveer 18803 
    oprot.writeFieldStop()
18804 
    oprot.writeStructEnd()
18805 
 
18806 
  def validate(self):
18807 
    return
18808 
 
18809 
 
18810 
  def __repr__(self):
18811 
    L = ['%s=%r' % (key, value)
18812 
      for key, value in self.__dict__.iteritems()]
18813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18814 
 
18815 
  def __eq__(self, other):
18816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18817 
 
18818 
  def __ne__(self, other):
18819 
    return not (self == other)
18820 
 
18821 
class markOrdersAsReversalInitiated_result:
18822 
  """
18823 
  Attributes:
18824 
   - ex
18825 
  """
18826 
 
18827 
  thrift_spec = (
18828 
    None, # 0
18829 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18830 
  )
18831 
 
18832 
  def __init__(self, ex=None,):
18833 
    self.ex = ex
18834 
 
18835 
  def read(self, iprot):
18836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18838 
      return
18839 
    iprot.readStructBegin()
18840 
    while True:
18841 
      (fname, ftype, fid) = iprot.readFieldBegin()
18842 
      if ftype == TType.STOP:
18843 
        break
18844 
      if fid == 1:
18845 
        if ftype == TType.STRUCT:
18846 
          self.ex = TransactionServiceException()
18847 
          self.ex.read(iprot)
18848 
        else:
18849 
          iprot.skip(ftype)
18850 
      else:
18851 
        iprot.skip(ftype)
18852 
      iprot.readFieldEnd()
18853 
    iprot.readStructEnd()
18854 
 
18855 
  def write(self, oprot):
18856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18858 
      return
18859 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
18860 
    if self.ex is not None:
18861 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18862 
      self.ex.write(oprot)
18863 
      oprot.writeFieldEnd()
18864 
    oprot.writeFieldStop()
18865 
    oprot.writeStructEnd()
18866 
 
18867 
  def validate(self):
18868 
    return
18869 
 
18870 
 
18871 
  def __repr__(self):
18872 
    L = ['%s=%r' % (key, value)
18873 
      for key, value in self.__dict__.iteritems()]
18874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18875 
 
18876 
  def __eq__(self, other):
18877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18878 
 
18879 
  def __ne__(self, other):
18880 
    return not (self == other)
18881 
 
18882 
class markOrdersAsNotAvailabke_args:
18883 
  """
18884 
  Attributes:
18885 
   - vendorId
18886 
   - itemId
18887 
   - quantity
18888 
   - estimate
4369 rajveer 18889 
   - isReminder
4303 rajveer 18890 
  """
18891 
 
18892 
  thrift_spec = (
18893 
    None, # 0
18894 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18895 
    (2, TType.I64, 'itemId', None, None, ), # 2
18896 
    (3, TType.I64, 'quantity', None, None, ), # 3
18897 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18898 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18899 
  )
18900 
 
4369 rajveer 18901 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18902 
    self.vendorId = vendorId
18903 
    self.itemId = itemId
18904 
    self.quantity = quantity
18905 
    self.estimate = estimate
4369 rajveer 18906 
    self.isReminder = isReminder
4303 rajveer 18907 
 
18908 
  def read(self, iprot):
18909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18911 
      return
18912 
    iprot.readStructBegin()
18913 
    while True:
18914 
      (fname, ftype, fid) = iprot.readFieldBegin()
18915 
      if ftype == TType.STOP:
18916 
        break
18917 
      if fid == 1:
18918 
        if ftype == TType.I64:
18919 
          self.vendorId = iprot.readI64();
18920 
        else:
18921 
          iprot.skip(ftype)
18922 
      elif fid == 2:
18923 
        if ftype == TType.I64:
18924 
          self.itemId = iprot.readI64();
18925 
        else:
18926 
          iprot.skip(ftype)
18927 
      elif fid == 3:
18928 
        if ftype == TType.I64:
18929 
          self.quantity = iprot.readI64();
18930 
        else:
18931 
          iprot.skip(ftype)
18932 
      elif fid == 4:
18933 
        if ftype == TType.I64:
18934 
          self.estimate = iprot.readI64();
18935 
        else:
18936 
          iprot.skip(ftype)
4369 rajveer 18937 
      elif fid == 5:
18938 
        if ftype == TType.BOOL:
18939 
          self.isReminder = iprot.readBool();
18940 
        else:
18941 
          iprot.skip(ftype)
4303 rajveer 18942 
      else:
18943 
        iprot.skip(ftype)
18944 
      iprot.readFieldEnd()
18945 
    iprot.readStructEnd()
18946 
 
18947 
  def write(self, oprot):
18948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18950 
      return
18951 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
18952 
    if self.vendorId is not None:
18953 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18954 
      oprot.writeI64(self.vendorId)
18955 
      oprot.writeFieldEnd()
18956 
    if self.itemId is not None:
18957 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18958 
      oprot.writeI64(self.itemId)
18959 
      oprot.writeFieldEnd()
18960 
    if self.quantity is not None:
18961 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18962 
      oprot.writeI64(self.quantity)
18963 
      oprot.writeFieldEnd()
18964 
    if self.estimate is not None:
18965 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18966 
      oprot.writeI64(self.estimate)
18967 
      oprot.writeFieldEnd()
4369 rajveer 18968 
    if self.isReminder is not None:
18969 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18970 
      oprot.writeBool(self.isReminder)
18971 
      oprot.writeFieldEnd()
4303 rajveer 18972 
    oprot.writeFieldStop()
18973 
    oprot.writeStructEnd()
18974 
 
18975 
  def validate(self):
18976 
    return
18977 
 
18978 
 
18979 
  def __repr__(self):
18980 
    L = ['%s=%r' % (key, value)
18981 
      for key, value in self.__dict__.iteritems()]
18982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18983 
 
18984 
  def __eq__(self, other):
18985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18986 
 
18987 
  def __ne__(self, other):
18988 
    return not (self == other)
18989 
 
18990 
class markOrdersAsNotAvailabke_result:
18991 
  """
18992 
  Attributes:
18993 
   - ex
18994 
  """
18995 
 
18996 
  thrift_spec = (
18997 
    None, # 0
18998 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18999 
  )
19000 
 
19001 
  def __init__(self, ex=None,):
19002 
    self.ex = ex
19003 
 
19004 
  def read(self, iprot):
19005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19007 
      return
19008 
    iprot.readStructBegin()
19009 
    while True:
19010 
      (fname, ftype, fid) = iprot.readFieldBegin()
19011 
      if ftype == TType.STOP:
19012 
        break
19013 
      if fid == 1:
19014 
        if ftype == TType.STRUCT:
19015 
          self.ex = TransactionServiceException()
19016 
          self.ex.read(iprot)
19017 
        else:
19018 
          iprot.skip(ftype)
19019 
      else:
19020 
        iprot.skip(ftype)
19021 
      iprot.readFieldEnd()
19022 
    iprot.readStructEnd()
19023 
 
19024 
  def write(self, oprot):
19025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19027 
      return
19028 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
19029 
    if self.ex is not None:
19030 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19031 
      self.ex.write(oprot)
19032 
      oprot.writeFieldEnd()
19033 
    oprot.writeFieldStop()
19034 
    oprot.writeStructEnd()
19035 
 
19036 
  def validate(self):
19037 
    return
19038 
 
19039 
 
19040 
  def __repr__(self):
19041 
    L = ['%s=%r' % (key, value)
19042 
      for key, value in self.__dict__.iteritems()]
19043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19044 
 
19045 
  def __eq__(self, other):
19046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19047 
 
19048 
  def __ne__(self, other):
19049 
    return not (self == other)
4369 rajveer 19050 
 
19051 
class markOrdersAsTimeout_args:
19052 
  """
19053 
  Attributes:
19054 
   - vendorId
19055 
  """
19056 
 
19057 
  thrift_spec = (
19058 
    None, # 0
19059 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19060 
  )
19061 
 
19062 
  def __init__(self, vendorId=None,):
19063 
    self.vendorId = vendorId
19064 
 
19065 
  def read(self, iprot):
19066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19068 
      return
19069 
    iprot.readStructBegin()
19070 
    while True:
19071 
      (fname, ftype, fid) = iprot.readFieldBegin()
19072 
      if ftype == TType.STOP:
19073 
        break
19074 
      if fid == 1:
19075 
        if ftype == TType.I64:
19076 
          self.vendorId = iprot.readI64();
19077 
        else:
19078 
          iprot.skip(ftype)
19079 
      else:
19080 
        iprot.skip(ftype)
19081 
      iprot.readFieldEnd()
19082 
    iprot.readStructEnd()
19083 
 
19084 
  def write(self, oprot):
19085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19087 
      return
19088 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
19089 
    if self.vendorId is not None:
19090 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19091 
      oprot.writeI64(self.vendorId)
19092 
      oprot.writeFieldEnd()
19093 
    oprot.writeFieldStop()
19094 
    oprot.writeStructEnd()
19095 
 
19096 
  def validate(self):
19097 
    return
19098 
 
19099 
 
19100 
  def __repr__(self):
19101 
    L = ['%s=%r' % (key, value)
19102 
      for key, value in self.__dict__.iteritems()]
19103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19104 
 
19105 
  def __eq__(self, other):
19106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19107 
 
19108 
  def __ne__(self, other):
19109 
    return not (self == other)
19110 
 
19111 
class markOrdersAsTimeout_result:
19112 
  """
19113 
  Attributes:
19114 
   - success
19115 
   - ex
19116 
  """
19117 
 
19118 
  thrift_spec = (
19119 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
19120 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19121 
  )
19122 
 
19123 
  def __init__(self, success=None, ex=None,):
19124 
    self.success = success
19125 
    self.ex = ex
19126 
 
19127 
  def read(self, iprot):
19128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19130 
      return
19131 
    iprot.readStructBegin()
19132 
    while True:
19133 
      (fname, ftype, fid) = iprot.readFieldBegin()
19134 
      if ftype == TType.STOP:
19135 
        break
19136 
      if fid == 0:
19137 
        if ftype == TType.MAP:
19138 
          self.success = {}
5031 varun.gupt 19139 
          (_ktype410, _vtype411, _size409 ) = iprot.readMapBegin()
19140 
          for _i413 in xrange(_size409):
19141 
            _key414 = iprot.readI32();
19142 
            _val415 = TimeoutSummary()
19143 
            _val415.read(iprot)
19144 
            self.success[_key414] = _val415
4369 rajveer 19145 
          iprot.readMapEnd()
19146 
        else:
19147 
          iprot.skip(ftype)
19148 
      elif fid == 1:
19149 
        if ftype == TType.STRUCT:
19150 
          self.ex = TransactionServiceException()
19151 
          self.ex.read(iprot)
19152 
        else:
19153 
          iprot.skip(ftype)
19154 
      else:
19155 
        iprot.skip(ftype)
19156 
      iprot.readFieldEnd()
19157 
    iprot.readStructEnd()
19158 
 
19159 
  def write(self, oprot):
19160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19162 
      return
19163 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
19164 
    if self.success is not None:
19165 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19166 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
5031 varun.gupt 19167 
      for kiter416,viter417 in self.success.items():
19168 
        oprot.writeI32(kiter416)
19169 
        viter417.write(oprot)
4369 rajveer 19170 
      oprot.writeMapEnd()
19171 
      oprot.writeFieldEnd()
19172 
    if self.ex is not None:
19173 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19174 
      self.ex.write(oprot)
19175 
      oprot.writeFieldEnd()
19176 
    oprot.writeFieldStop()
19177 
    oprot.writeStructEnd()
19178 
 
19179 
  def validate(self):
19180 
    return
19181 
 
19182 
 
19183 
  def __repr__(self):
19184 
    L = ['%s=%r' % (key, value)
19185 
      for key, value in self.__dict__.iteritems()]
19186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19187 
 
19188 
  def __eq__(self, other):
19189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19190 
 
19191 
  def __ne__(self, other):
19192 
    return not (self == other)
4386 anupam.sin 19193 
 
4662 rajveer 19194 
class markOrderAsLostInTransit_args:
19195 
  """
19196 
  Attributes:
19197 
   - orderId
19198 
  """
19199 
 
19200 
  thrift_spec = (
19201 
    None, # 0
19202 
    (1, TType.I64, 'orderId', None, None, ), # 1
19203 
  )
19204 
 
19205 
  def __init__(self, orderId=None,):
19206 
    self.orderId = orderId
19207 
 
19208 
  def read(self, iprot):
19209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19211 
      return
19212 
    iprot.readStructBegin()
19213 
    while True:
19214 
      (fname, ftype, fid) = iprot.readFieldBegin()
19215 
      if ftype == TType.STOP:
19216 
        break
19217 
      if fid == 1:
19218 
        if ftype == TType.I64:
19219 
          self.orderId = iprot.readI64();
19220 
        else:
19221 
          iprot.skip(ftype)
19222 
      else:
19223 
        iprot.skip(ftype)
19224 
      iprot.readFieldEnd()
19225 
    iprot.readStructEnd()
19226 
 
19227 
  def write(self, oprot):
19228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19230 
      return
19231 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
19232 
    if self.orderId is not None:
19233 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19234 
      oprot.writeI64(self.orderId)
19235 
      oprot.writeFieldEnd()
19236 
    oprot.writeFieldStop()
19237 
    oprot.writeStructEnd()
19238 
 
19239 
  def validate(self):
19240 
    return
19241 
 
19242 
 
19243 
  def __repr__(self):
19244 
    L = ['%s=%r' % (key, value)
19245 
      for key, value in self.__dict__.iteritems()]
19246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19247 
 
19248 
  def __eq__(self, other):
19249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19250 
 
19251 
  def __ne__(self, other):
19252 
    return not (self == other)
19253 
 
19254 
class markOrderAsLostInTransit_result:
19255 
  """
19256 
  Attributes:
19257 
   - success
19258 
   - ex
19259 
  """
19260 
 
19261 
  thrift_spec = (
19262 
    (0, TType.BOOL, 'success', None, None, ), # 0
19263 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19264 
  )
19265 
 
19266 
  def __init__(self, success=None, ex=None,):
19267 
    self.success = success
19268 
    self.ex = ex
19269 
 
19270 
  def read(self, iprot):
19271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19273 
      return
19274 
    iprot.readStructBegin()
19275 
    while True:
19276 
      (fname, ftype, fid) = iprot.readFieldBegin()
19277 
      if ftype == TType.STOP:
19278 
        break
19279 
      if fid == 0:
19280 
        if ftype == TType.BOOL:
19281 
          self.success = iprot.readBool();
19282 
        else:
19283 
          iprot.skip(ftype)
19284 
      elif fid == 1:
19285 
        if ftype == TType.STRUCT:
19286 
          self.ex = TransactionServiceException()
19287 
          self.ex.read(iprot)
19288 
        else:
19289 
          iprot.skip(ftype)
19290 
      else:
19291 
        iprot.skip(ftype)
19292 
      iprot.readFieldEnd()
19293 
    iprot.readStructEnd()
19294 
 
19295 
  def write(self, oprot):
19296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19298 
      return
19299 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
19300 
    if self.success is not None:
19301 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19302 
      oprot.writeBool(self.success)
19303 
      oprot.writeFieldEnd()
19304 
    if self.ex is not None:
19305 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19306 
      self.ex.write(oprot)
19307 
      oprot.writeFieldEnd()
19308 
    oprot.writeFieldStop()
19309 
    oprot.writeStructEnd()
19310 
 
19311 
  def validate(self):
19312 
    return
19313 
 
19314 
 
19315 
  def __repr__(self):
19316 
    L = ['%s=%r' % (key, value)
19317 
      for key, value in self.__dict__.iteritems()]
19318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19319 
 
19320 
  def __eq__(self, other):
19321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19322 
 
19323 
  def __ne__(self, other):
19324 
    return not (self == other)
19325 
 
4386 anupam.sin 19326 
class getOrderForAwb_args:
19327 
  """
19328 
  Attributes:
19329 
   - awb
19330 
  """
19331 
 
19332 
  thrift_spec = (
19333 
    None, # 0
19334 
    (1, TType.STRING, 'awb', None, None, ), # 1
19335 
  )
19336 
 
19337 
  def __init__(self, awb=None,):
19338 
    self.awb = awb
19339 
 
19340 
  def read(self, iprot):
19341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19343 
      return
19344 
    iprot.readStructBegin()
19345 
    while True:
19346 
      (fname, ftype, fid) = iprot.readFieldBegin()
19347 
      if ftype == TType.STOP:
19348 
        break
19349 
      if fid == 1:
19350 
        if ftype == TType.STRING:
19351 
          self.awb = iprot.readString();
19352 
        else:
19353 
          iprot.skip(ftype)
19354 
      else:
19355 
        iprot.skip(ftype)
19356 
      iprot.readFieldEnd()
19357 
    iprot.readStructEnd()
19358 
 
19359 
  def write(self, oprot):
19360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19362 
      return
19363 
    oprot.writeStructBegin('getOrderForAwb_args')
19364 
    if self.awb is not None:
19365 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
19366 
      oprot.writeString(self.awb)
19367 
      oprot.writeFieldEnd()
19368 
    oprot.writeFieldStop()
19369 
    oprot.writeStructEnd()
19370 
 
19371 
  def validate(self):
19372 
    return
19373 
 
19374 
 
19375 
  def __repr__(self):
19376 
    L = ['%s=%r' % (key, value)
19377 
      for key, value in self.__dict__.iteritems()]
19378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19379 
 
19380 
  def __eq__(self, other):
19381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19382 
 
19383 
  def __ne__(self, other):
19384 
    return not (self == other)
19385 
 
19386 
class getOrderForAwb_result:
19387 
  """
19388 
  Attributes:
19389 
   - success
19390 
   - ex
19391 
  """
19392 
 
19393 
  thrift_spec = (
19394 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19395 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19396 
  )
19397 
 
19398 
  def __init__(self, success=None, ex=None,):
19399 
    self.success = success
19400 
    self.ex = ex
19401 
 
19402 
  def read(self, iprot):
19403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19405 
      return
19406 
    iprot.readStructBegin()
19407 
    while True:
19408 
      (fname, ftype, fid) = iprot.readFieldBegin()
19409 
      if ftype == TType.STOP:
19410 
        break
19411 
      if fid == 0:
19412 
        if ftype == TType.STRUCT:
19413 
          self.success = Order()
19414 
          self.success.read(iprot)
19415 
        else:
19416 
          iprot.skip(ftype)
19417 
      elif fid == 1:
19418 
        if ftype == TType.STRUCT:
19419 
          self.ex = TransactionServiceException()
19420 
          self.ex.read(iprot)
19421 
        else:
19422 
          iprot.skip(ftype)
19423 
      else:
19424 
        iprot.skip(ftype)
19425 
      iprot.readFieldEnd()
19426 
    iprot.readStructEnd()
19427 
 
19428 
  def write(self, oprot):
19429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19431 
      return
19432 
    oprot.writeStructBegin('getOrderForAwb_result')
19433 
    if self.success is not None:
19434 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19435 
      self.success.write(oprot)
19436 
      oprot.writeFieldEnd()
19437 
    if self.ex is not None:
19438 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19439 
      self.ex.write(oprot)
19440 
      oprot.writeFieldEnd()
19441 
    oprot.writeFieldStop()
19442 
    oprot.writeStructEnd()
19443 
 
19444 
  def validate(self):
19445 
    return
19446 
 
19447 
 
19448 
  def __repr__(self):
19449 
    L = ['%s=%r' % (key, value)
19450 
      for key, value in self.__dict__.iteritems()]
19451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19452 
 
19453 
  def __eq__(self, other):
19454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19455 
 
19456 
  def __ne__(self, other):
19457 
    return not (self == other)
4506 phani.kuma 19458 
 
19459 
class getOrdersForProviderForStatus_args:
19460 
  """
19461 
  Attributes:
19462 
   - logistics_provider_id
4910 phani.kuma 19463 
   - order_status_list
4506 phani.kuma 19464 
  """
19465 
 
19466 
  thrift_spec = (
19467 
    None, # 0
19468 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 19469 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 19470 
  )
19471 
 
4910 phani.kuma 19472 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 19473 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 19474 
    self.order_status_list = order_status_list
4506 phani.kuma 19475 
 
19476 
  def read(self, iprot):
19477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19479 
      return
19480 
    iprot.readStructBegin()
19481 
    while True:
19482 
      (fname, ftype, fid) = iprot.readFieldBegin()
19483 
      if ftype == TType.STOP:
19484 
        break
19485 
      if fid == 1:
19486 
        if ftype == TType.I64:
19487 
          self.logistics_provider_id = iprot.readI64();
19488 
        else:
19489 
          iprot.skip(ftype)
19490 
      elif fid == 2:
4910 phani.kuma 19491 
        if ftype == TType.LIST:
19492 
          self.order_status_list = []
5031 varun.gupt 19493 
          (_etype421, _size418) = iprot.readListBegin()
19494 
          for _i422 in xrange(_size418):
19495 
            _elem423 = iprot.readI32();
19496 
            self.order_status_list.append(_elem423)
4910 phani.kuma 19497 
          iprot.readListEnd()
4506 phani.kuma 19498 
        else:
19499 
          iprot.skip(ftype)
19500 
      else:
19501 
        iprot.skip(ftype)
19502 
      iprot.readFieldEnd()
19503 
    iprot.readStructEnd()
19504 
 
19505 
  def write(self, oprot):
19506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19508 
      return
19509 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
19510 
    if self.logistics_provider_id is not None:
19511 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
19512 
      oprot.writeI64(self.logistics_provider_id)
19513 
      oprot.writeFieldEnd()
4910 phani.kuma 19514 
    if self.order_status_list is not None:
19515 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
19516 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
5031 varun.gupt 19517 
      for iter424 in self.order_status_list:
19518 
        oprot.writeI32(iter424)
4910 phani.kuma 19519 
      oprot.writeListEnd()
4506 phani.kuma 19520 
      oprot.writeFieldEnd()
19521 
    oprot.writeFieldStop()
19522 
    oprot.writeStructEnd()
19523 
 
19524 
  def validate(self):
19525 
    return
19526 
 
19527 
 
19528 
  def __repr__(self):
19529 
    L = ['%s=%r' % (key, value)
19530 
      for key, value in self.__dict__.iteritems()]
19531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19532 
 
19533 
  def __eq__(self, other):
19534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19535 
 
19536 
  def __ne__(self, other):
19537 
    return not (self == other)
19538 
 
19539 
class getOrdersForProviderForStatus_result:
19540 
  """
19541 
  Attributes:
19542 
   - success
19543 
   - ex
19544 
  """
19545 
 
19546 
  thrift_spec = (
19547 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19548 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19549 
  )
19550 
 
19551 
  def __init__(self, success=None, ex=None,):
19552 
    self.success = success
19553 
    self.ex = ex
19554 
 
19555 
  def read(self, iprot):
19556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19558 
      return
19559 
    iprot.readStructBegin()
19560 
    while True:
19561 
      (fname, ftype, fid) = iprot.readFieldBegin()
19562 
      if ftype == TType.STOP:
19563 
        break
19564 
      if fid == 0:
19565 
        if ftype == TType.LIST:
19566 
          self.success = []
5031 varun.gupt 19567 
          (_etype428, _size425) = iprot.readListBegin()
19568 
          for _i429 in xrange(_size425):
19569 
            _elem430 = Order()
19570 
            _elem430.read(iprot)
19571 
            self.success.append(_elem430)
4506 phani.kuma 19572 
          iprot.readListEnd()
19573 
        else:
19574 
          iprot.skip(ftype)
19575 
      elif fid == 1:
19576 
        if ftype == TType.STRUCT:
19577 
          self.ex = TransactionServiceException()
19578 
          self.ex.read(iprot)
19579 
        else:
19580 
          iprot.skip(ftype)
19581 
      else:
19582 
        iprot.skip(ftype)
19583 
      iprot.readFieldEnd()
19584 
    iprot.readStructEnd()
19585 
 
19586 
  def write(self, oprot):
19587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19589 
      return
19590 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
19591 
    if self.success is not None:
19592 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19593 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19594 
      for iter431 in self.success:
19595 
        iter431.write(oprot)
4506 phani.kuma 19596 
      oprot.writeListEnd()
19597 
      oprot.writeFieldEnd()
19598 
    if self.ex is not None:
19599 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19600 
      self.ex.write(oprot)
19601 
      oprot.writeFieldEnd()
19602 
    oprot.writeFieldStop()
19603 
    oprot.writeStructEnd()
19604 
 
19605 
  def validate(self):
19606 
    return
19607 
 
19608 
 
19609 
  def __repr__(self):
19610 
    L = ['%s=%r' % (key, value)
19611 
      for key, value in self.__dict__.iteritems()]
19612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19613 
 
19614 
  def __eq__(self, other):
19615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19616 
 
19617 
  def __ne__(self, other):
19618 
    return not (self == other)
4600 varun.gupt 19619 
 
19620 
class getBilledOrdersForVendor_args:
19621 
  """
19622 
  Attributes:
19623 
   - vendorId
19624 
   - billingDateFrom
19625 
   - billingDateTo
19626 
  """
19627 
 
19628 
  thrift_spec = (
19629 
    None, # 0
19630 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19631 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
19632 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
19633 
  )
19634 
 
19635 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
19636 
    self.vendorId = vendorId
19637 
    self.billingDateFrom = billingDateFrom
19638 
    self.billingDateTo = billingDateTo
19639 
 
19640 
  def read(self, iprot):
19641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19643 
      return
19644 
    iprot.readStructBegin()
19645 
    while True:
19646 
      (fname, ftype, fid) = iprot.readFieldBegin()
19647 
      if ftype == TType.STOP:
19648 
        break
19649 
      if fid == 1:
19650 
        if ftype == TType.I64:
19651 
          self.vendorId = iprot.readI64();
19652 
        else:
19653 
          iprot.skip(ftype)
19654 
      elif fid == 2:
19655 
        if ftype == TType.I64:
19656 
          self.billingDateFrom = iprot.readI64();
19657 
        else:
19658 
          iprot.skip(ftype)
19659 
      elif fid == 3:
19660 
        if ftype == TType.I64:
19661 
          self.billingDateTo = iprot.readI64();
19662 
        else:
19663 
          iprot.skip(ftype)
19664 
      else:
19665 
        iprot.skip(ftype)
19666 
      iprot.readFieldEnd()
19667 
    iprot.readStructEnd()
19668 
 
19669 
  def write(self, oprot):
19670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19672 
      return
19673 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
19674 
    if self.vendorId is not None:
19675 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19676 
      oprot.writeI64(self.vendorId)
19677 
      oprot.writeFieldEnd()
19678 
    if self.billingDateFrom is not None:
19679 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
19680 
      oprot.writeI64(self.billingDateFrom)
19681 
      oprot.writeFieldEnd()
19682 
    if self.billingDateTo is not None:
19683 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
19684 
      oprot.writeI64(self.billingDateTo)
19685 
      oprot.writeFieldEnd()
19686 
    oprot.writeFieldStop()
19687 
    oprot.writeStructEnd()
19688 
 
19689 
  def validate(self):
19690 
    return
19691 
 
19692 
 
19693 
  def __repr__(self):
19694 
    L = ['%s=%r' % (key, value)
19695 
      for key, value in self.__dict__.iteritems()]
19696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19697 
 
19698 
  def __eq__(self, other):
19699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19700 
 
19701 
  def __ne__(self, other):
19702 
    return not (self == other)
19703 
 
19704 
class getBilledOrdersForVendor_result:
19705 
  """
19706 
  Attributes:
19707 
   - success
19708 
   - ex
19709 
  """
19710 
 
19711 
  thrift_spec = (
19712 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19713 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19714 
  )
19715 
 
19716 
  def __init__(self, success=None, ex=None,):
19717 
    self.success = success
19718 
    self.ex = ex
19719 
 
19720 
  def read(self, iprot):
19721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19723 
      return
19724 
    iprot.readStructBegin()
19725 
    while True:
19726 
      (fname, ftype, fid) = iprot.readFieldBegin()
19727 
      if ftype == TType.STOP:
19728 
        break
19729 
      if fid == 0:
19730 
        if ftype == TType.LIST:
19731 
          self.success = []
5031 varun.gupt 19732 
          (_etype435, _size432) = iprot.readListBegin()
19733 
          for _i436 in xrange(_size432):
19734 
            _elem437 = Order()
19735 
            _elem437.read(iprot)
19736 
            self.success.append(_elem437)
4600 varun.gupt 19737 
          iprot.readListEnd()
19738 
        else:
19739 
          iprot.skip(ftype)
19740 
      elif fid == 1:
19741 
        if ftype == TType.STRUCT:
19742 
          self.ex = TransactionServiceException()
19743 
          self.ex.read(iprot)
19744 
        else:
19745 
          iprot.skip(ftype)
19746 
      else:
19747 
        iprot.skip(ftype)
19748 
      iprot.readFieldEnd()
19749 
    iprot.readStructEnd()
19750 
 
19751 
  def write(self, oprot):
19752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19754 
      return
19755 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
19756 
    if self.success is not None:
19757 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19758 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19759 
      for iter438 in self.success:
19760 
        iter438.write(oprot)
4600 varun.gupt 19761 
      oprot.writeListEnd()
19762 
      oprot.writeFieldEnd()
19763 
    if self.ex is not None:
19764 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19765 
      self.ex.write(oprot)
19766 
      oprot.writeFieldEnd()
19767 
    oprot.writeFieldStop()
19768 
    oprot.writeStructEnd()
19769 
 
19770 
  def validate(self):
19771 
    return
19772 
 
19773 
 
19774 
  def __repr__(self):
19775 
    L = ['%s=%r' % (key, value)
19776 
      for key, value in self.__dict__.iteritems()]
19777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19778 
 
19779 
  def __eq__(self, other):
19780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19781 
 
19782 
  def __ne__(self, other):
19783 
    return not (self == other)
19784 
 
4607 rajveer 19785 
class getSlippedSippingDateOrders_args:
19786 
 
19787 
  thrift_spec = (
19788 
  )
19789 
 
19790 
  def read(self, iprot):
19791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19793 
      return
19794 
    iprot.readStructBegin()
19795 
    while True:
19796 
      (fname, ftype, fid) = iprot.readFieldBegin()
19797 
      if ftype == TType.STOP:
19798 
        break
19799 
      else:
19800 
        iprot.skip(ftype)
19801 
      iprot.readFieldEnd()
19802 
    iprot.readStructEnd()
19803 
 
19804 
  def write(self, oprot):
19805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19807 
      return
19808 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
19809 
    oprot.writeFieldStop()
19810 
    oprot.writeStructEnd()
19811 
 
19812 
  def validate(self):
19813 
    return
19814 
 
19815 
 
19816 
  def __repr__(self):
19817 
    L = ['%s=%r' % (key, value)
19818 
      for key, value in self.__dict__.iteritems()]
19819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19820 
 
19821 
  def __eq__(self, other):
19822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19823 
 
19824 
  def __ne__(self, other):
19825 
    return not (self == other)
19826 
 
19827 
class getSlippedSippingDateOrders_result:
19828 
  """
19829 
  Attributes:
19830 
   - success
19831 
   - ex
19832 
  """
19833 
 
19834 
  thrift_spec = (
19835 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19836 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19837 
  )
19838 
 
19839 
  def __init__(self, success=None, ex=None,):
19840 
    self.success = success
19841 
    self.ex = ex
19842 
 
19843 
  def read(self, iprot):
19844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19846 
      return
19847 
    iprot.readStructBegin()
19848 
    while True:
19849 
      (fname, ftype, fid) = iprot.readFieldBegin()
19850 
      if ftype == TType.STOP:
19851 
        break
19852 
      if fid == 0:
19853 
        if ftype == TType.LIST:
19854 
          self.success = []
5031 varun.gupt 19855 
          (_etype442, _size439) = iprot.readListBegin()
19856 
          for _i443 in xrange(_size439):
19857 
            _elem444 = Order()
19858 
            _elem444.read(iprot)
19859 
            self.success.append(_elem444)
4607 rajveer 19860 
          iprot.readListEnd()
19861 
        else:
19862 
          iprot.skip(ftype)
19863 
      elif fid == 1:
19864 
        if ftype == TType.STRUCT:
19865 
          self.ex = TransactionServiceException()
19866 
          self.ex.read(iprot)
19867 
        else:
19868 
          iprot.skip(ftype)
19869 
      else:
19870 
        iprot.skip(ftype)
19871 
      iprot.readFieldEnd()
19872 
    iprot.readStructEnd()
19873 
 
19874 
  def write(self, oprot):
19875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19877 
      return
19878 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
19879 
    if self.success is not None:
19880 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19881 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19882 
      for iter445 in self.success:
19883 
        iter445.write(oprot)
4607 rajveer 19884 
      oprot.writeListEnd()
19885 
      oprot.writeFieldEnd()
19886 
    if self.ex is not None:
19887 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19888 
      self.ex.write(oprot)
19889 
      oprot.writeFieldEnd()
19890 
    oprot.writeFieldStop()
19891 
    oprot.writeStructEnd()
19892 
 
19893 
  def validate(self):
19894 
    return
19895 
 
19896 
 
19897 
  def __repr__(self):
19898 
    L = ['%s=%r' % (key, value)
19899 
      for key, value in self.__dict__.iteritems()]
19900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19901 
 
19902 
  def __eq__(self, other):
19903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19904 
 
19905 
  def __ne__(self, other):
19906 
    return not (self == other)
19907 
 
4709 rajveer 19908 
class getCancelledOrders_args:
19909 
  """
19910 
  Attributes:
19911 
   - cancelDateFrom
19912 
   - cancelDateTo
19913 
  """
19914 
 
19915 
  thrift_spec = (
19916 
    None, # 0
19917 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
19918 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
19919 
  )
19920 
 
19921 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
19922 
    self.cancelDateFrom = cancelDateFrom
19923 
    self.cancelDateTo = cancelDateTo
19924 
 
19925 
  def read(self, iprot):
19926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19928 
      return
19929 
    iprot.readStructBegin()
19930 
    while True:
19931 
      (fname, ftype, fid) = iprot.readFieldBegin()
19932 
      if ftype == TType.STOP:
19933 
        break
19934 
      if fid == 1:
19935 
        if ftype == TType.I64:
19936 
          self.cancelDateFrom = iprot.readI64();
19937 
        else:
19938 
          iprot.skip(ftype)
19939 
      elif fid == 2:
19940 
        if ftype == TType.I64:
19941 
          self.cancelDateTo = iprot.readI64();
19942 
        else:
19943 
          iprot.skip(ftype)
19944 
      else:
19945 
        iprot.skip(ftype)
19946 
      iprot.readFieldEnd()
19947 
    iprot.readStructEnd()
19948 
 
19949 
  def write(self, oprot):
19950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19952 
      return
19953 
    oprot.writeStructBegin('getCancelledOrders_args')
19954 
    if self.cancelDateFrom is not None:
19955 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
19956 
      oprot.writeI64(self.cancelDateFrom)
19957 
      oprot.writeFieldEnd()
19958 
    if self.cancelDateTo is not None:
19959 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
19960 
      oprot.writeI64(self.cancelDateTo)
19961 
      oprot.writeFieldEnd()
19962 
    oprot.writeFieldStop()
19963 
    oprot.writeStructEnd()
19964 
 
19965 
  def validate(self):
19966 
    return
19967 
 
19968 
 
19969 
  def __repr__(self):
19970 
    L = ['%s=%r' % (key, value)
19971 
      for key, value in self.__dict__.iteritems()]
19972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19973 
 
19974 
  def __eq__(self, other):
19975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19976 
 
19977 
  def __ne__(self, other):
19978 
    return not (self == other)
19979 
 
19980 
class getCancelledOrders_result:
19981 
  """
19982 
  Attributes:
19983 
   - success
19984 
   - ex
19985 
  """
19986 
 
19987 
  thrift_spec = (
19988 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19989 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19990 
  )
19991 
 
19992 
  def __init__(self, success=None, ex=None,):
19993 
    self.success = success
19994 
    self.ex = ex
19995 
 
19996 
  def read(self, iprot):
19997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19999 
      return
20000 
    iprot.readStructBegin()
20001 
    while True:
20002 
      (fname, ftype, fid) = iprot.readFieldBegin()
20003 
      if ftype == TType.STOP:
20004 
        break
20005 
      if fid == 0:
20006 
        if ftype == TType.LIST:
20007 
          self.success = []
5031 varun.gupt 20008 
          (_etype449, _size446) = iprot.readListBegin()
20009 
          for _i450 in xrange(_size446):
20010 
            _elem451 = Order()
20011 
            _elem451.read(iprot)
20012 
            self.success.append(_elem451)
4709 rajveer 20013 
          iprot.readListEnd()
20014 
        else:
20015 
          iprot.skip(ftype)
20016 
      elif fid == 1:
20017 
        if ftype == TType.STRUCT:
20018 
          self.ex = TransactionServiceException()
20019 
          self.ex.read(iprot)
20020 
        else:
20021 
          iprot.skip(ftype)
20022 
      else:
20023 
        iprot.skip(ftype)
20024 
      iprot.readFieldEnd()
20025 
    iprot.readStructEnd()
20026 
 
20027 
  def write(self, oprot):
20028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20030 
      return
20031 
    oprot.writeStructBegin('getCancelledOrders_result')
20032 
    if self.success is not None:
20033 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20034 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 20035 
      for iter452 in self.success:
20036 
        iter452.write(oprot)
4709 rajveer 20037 
      oprot.writeListEnd()
20038 
      oprot.writeFieldEnd()
20039 
    if self.ex is not None:
20040 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20041 
      self.ex.write(oprot)
20042 
      oprot.writeFieldEnd()
20043 
    oprot.writeFieldStop()
20044 
    oprot.writeStructEnd()
20045 
 
20046 
  def validate(self):
20047 
    return
20048 
 
20049 
 
20050 
  def __repr__(self):
20051 
    L = ['%s=%r' % (key, value)
20052 
      for key, value in self.__dict__.iteritems()]
20053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20054 
 
20055 
  def __eq__(self, other):
20056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20057 
 
20058 
  def __ne__(self, other):
20059 
    return not (self == other)
20060 
 
4600 varun.gupt 20061 
class saveBluedartSettlements_args:
20062 
  """
20063 
  Attributes:
20064 
   - mapAWBAndAmount
20065 
  """
20066 
 
20067 
  thrift_spec = (
20068 
    None, # 0
20069 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
20070 
  )
20071 
 
20072 
  def __init__(self, mapAWBAndAmount=None,):
20073 
    self.mapAWBAndAmount = mapAWBAndAmount
20074 
 
20075 
  def read(self, iprot):
20076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20078 
      return
20079 
    iprot.readStructBegin()
20080 
    while True:
20081 
      (fname, ftype, fid) = iprot.readFieldBegin()
20082 
      if ftype == TType.STOP:
20083 
        break
20084 
      if fid == 1:
20085 
        if ftype == TType.MAP:
20086 
          self.mapAWBAndAmount = {}
5031 varun.gupt 20087 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
20088 
          for _i457 in xrange(_size453):
20089 
            _key458 = iprot.readI64();
20090 
            _val459 = iprot.readDouble();
20091 
            self.mapAWBAndAmount[_key458] = _val459
4600 varun.gupt 20092 
          iprot.readMapEnd()
20093 
        else:
20094 
          iprot.skip(ftype)
20095 
      else:
20096 
        iprot.skip(ftype)
20097 
      iprot.readFieldEnd()
20098 
    iprot.readStructEnd()
20099 
 
20100 
  def write(self, oprot):
20101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20103 
      return
20104 
    oprot.writeStructBegin('saveBluedartSettlements_args')
20105 
    if self.mapAWBAndAmount is not None:
20106 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
20107 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
5031 varun.gupt 20108 
      for kiter460,viter461 in self.mapAWBAndAmount.items():
20109 
        oprot.writeI64(kiter460)
20110 
        oprot.writeDouble(viter461)
4600 varun.gupt 20111 
      oprot.writeMapEnd()
20112 
      oprot.writeFieldEnd()
20113 
    oprot.writeFieldStop()
20114 
    oprot.writeStructEnd()
20115 
 
20116 
  def validate(self):
20117 
    return
20118 
 
20119 
 
20120 
  def __repr__(self):
20121 
    L = ['%s=%r' % (key, value)
20122 
      for key, value in self.__dict__.iteritems()]
20123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20124 
 
20125 
  def __eq__(self, other):
20126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20127 
 
20128 
  def __ne__(self, other):
20129 
    return not (self == other)
20130 
 
20131 
class saveBluedartSettlements_result:
20132 
  """
20133 
  Attributes:
20134 
   - ex
20135 
  """
20136 
 
20137 
  thrift_spec = (
20138 
    None, # 0
20139 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20140 
  )
20141 
 
20142 
  def __init__(self, ex=None,):
20143 
    self.ex = ex
20144 
 
20145 
  def read(self, iprot):
20146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20148 
      return
20149 
    iprot.readStructBegin()
20150 
    while True:
20151 
      (fname, ftype, fid) = iprot.readFieldBegin()
20152 
      if ftype == TType.STOP:
20153 
        break
20154 
      if fid == 1:
20155 
        if ftype == TType.STRUCT:
20156 
          self.ex = TransactionServiceException()
20157 
          self.ex.read(iprot)
20158 
        else:
20159 
          iprot.skip(ftype)
20160 
      else:
20161 
        iprot.skip(ftype)
20162 
      iprot.readFieldEnd()
20163 
    iprot.readStructEnd()
20164 
 
20165 
  def write(self, oprot):
20166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20168 
      return
20169 
    oprot.writeStructBegin('saveBluedartSettlements_result')
20170 
    if self.ex is not None:
20171 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20172 
      self.ex.write(oprot)
20173 
      oprot.writeFieldEnd()
20174 
    oprot.writeFieldStop()
20175 
    oprot.writeStructEnd()
20176 
 
20177 
  def validate(self):
20178 
    return
20179 
 
20180 
 
20181 
  def __repr__(self):
20182 
    L = ['%s=%r' % (key, value)
20183 
      for key, value in self.__dict__.iteritems()]
20184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20185 
 
20186 
  def __eq__(self, other):
20187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20188 
 
20189 
  def __ne__(self, other):
20190 
    return not (self == other)
20191 
 
20192 
class savePaymentSettlements_args:
20193 
  """
20194 
  Attributes:
20195 
   - settlementDate
20196 
   - paymentGatewayId
4905 varun.gupt 20197 
   - referenceId
4600 varun.gupt 20198 
   - serviceTax
20199 
   - otherCharges
20200 
   - netCollection
20201 
  """
20202 
 
20203 
  thrift_spec = (
20204 
    None, # 0
20205 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
20206 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 20207 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 20208 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
20209 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
20210 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
20211 
  )
20212 
 
4905 varun.gupt 20213 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 20214 
    self.settlementDate = settlementDate
20215 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 20216 
    self.referenceId = referenceId
4600 varun.gupt 20217 
    self.serviceTax = serviceTax
20218 
    self.otherCharges = otherCharges
20219 
    self.netCollection = netCollection
20220 
 
20221 
  def read(self, iprot):
20222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20224 
      return
20225 
    iprot.readStructBegin()
20226 
    while True:
20227 
      (fname, ftype, fid) = iprot.readFieldBegin()
20228 
      if ftype == TType.STOP:
20229 
        break
20230 
      if fid == 1:
20231 
        if ftype == TType.I64:
20232 
          self.settlementDate = iprot.readI64();
20233 
        else:
20234 
          iprot.skip(ftype)
20235 
      elif fid == 2:
20236 
        if ftype == TType.I64:
20237 
          self.paymentGatewayId = iprot.readI64();
20238 
        else:
20239 
          iprot.skip(ftype)
20240 
      elif fid == 3:
20241 
        if ftype == TType.I64:
4905 varun.gupt 20242 
          self.referenceId = iprot.readI64();
4600 varun.gupt 20243 
        else:
20244 
          iprot.skip(ftype)
20245 
      elif fid == 4:
20246 
        if ftype == TType.DOUBLE:
20247 
          self.serviceTax = iprot.readDouble();
20248 
        else:
20249 
          iprot.skip(ftype)
20250 
      elif fid == 5:
20251 
        if ftype == TType.DOUBLE:
20252 
          self.otherCharges = iprot.readDouble();
20253 
        else:
20254 
          iprot.skip(ftype)
20255 
      elif fid == 6:
20256 
        if ftype == TType.DOUBLE:
20257 
          self.netCollection = iprot.readDouble();
20258 
        else:
20259 
          iprot.skip(ftype)
20260 
      else:
20261 
        iprot.skip(ftype)
20262 
      iprot.readFieldEnd()
20263 
    iprot.readStructEnd()
20264 
 
20265 
  def write(self, oprot):
20266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20268 
      return
20269 
    oprot.writeStructBegin('savePaymentSettlements_args')
20270 
    if self.settlementDate is not None:
20271 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
20272 
      oprot.writeI64(self.settlementDate)
20273 
      oprot.writeFieldEnd()
20274 
    if self.paymentGatewayId is not None:
20275 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
20276 
      oprot.writeI64(self.paymentGatewayId)
20277 
      oprot.writeFieldEnd()
4905 varun.gupt 20278 
    if self.referenceId is not None:
20279 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
20280 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 20281 
      oprot.writeFieldEnd()
20282 
    if self.serviceTax is not None:
20283 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
20284 
      oprot.writeDouble(self.serviceTax)
20285 
      oprot.writeFieldEnd()
20286 
    if self.otherCharges is not None:
20287 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
20288 
      oprot.writeDouble(self.otherCharges)
20289 
      oprot.writeFieldEnd()
20290 
    if self.netCollection is not None:
20291 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
20292 
      oprot.writeDouble(self.netCollection)
20293 
      oprot.writeFieldEnd()
20294 
    oprot.writeFieldStop()
20295 
    oprot.writeStructEnd()
20296 
 
20297 
  def validate(self):
20298 
    return
20299 
 
20300 
 
20301 
  def __repr__(self):
20302 
    L = ['%s=%r' % (key, value)
20303 
      for key, value in self.__dict__.iteritems()]
20304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20305 
 
20306 
  def __eq__(self, other):
20307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20308 
 
20309 
  def __ne__(self, other):
20310 
    return not (self == other)
20311 
 
20312 
class savePaymentSettlements_result:
20313 
  """
20314 
  Attributes:
20315 
   - ex
20316 
  """
20317 
 
20318 
  thrift_spec = (
20319 
    None, # 0
20320 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20321 
  )
20322 
 
20323 
  def __init__(self, ex=None,):
20324 
    self.ex = ex
20325 
 
20326 
  def read(self, iprot):
20327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20329 
      return
20330 
    iprot.readStructBegin()
20331 
    while True:
20332 
      (fname, ftype, fid) = iprot.readFieldBegin()
20333 
      if ftype == TType.STOP:
20334 
        break
20335 
      if fid == 1:
20336 
        if ftype == TType.STRUCT:
20337 
          self.ex = TransactionServiceException()
20338 
          self.ex.read(iprot)
20339 
        else:
20340 
          iprot.skip(ftype)
20341 
      else:
20342 
        iprot.skip(ftype)
20343 
      iprot.readFieldEnd()
20344 
    iprot.readStructEnd()
20345 
 
20346 
  def write(self, oprot):
20347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20349 
      return
20350 
    oprot.writeStructBegin('savePaymentSettlements_result')
20351 
    if self.ex is not None:
20352 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20353 
      self.ex.write(oprot)
20354 
      oprot.writeFieldEnd()
20355 
    oprot.writeFieldStop()
20356 
    oprot.writeStructEnd()
20357 
 
20358 
  def validate(self):
20359 
    return
20360 
 
20361 
 
20362 
  def __repr__(self):
20363 
    L = ['%s=%r' % (key, value)
20364 
      for key, value in self.__dict__.iteritems()]
20365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20366 
 
20367 
  def __eq__(self, other):
20368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20369 
 
20370 
  def __ne__(self, other):
20371 
    return not (self == other)
20372 
 
20373 
class saveEBSSettlementSummary_args:
20374 
  """
20375 
  Attributes:
20376 
   - settlementId
20377 
   - settlementDate
20378 
   - transactionDateFrom
20379 
   - transactionDateTo
20380 
   - amount
20381 
  """
20382 
 
20383 
  thrift_spec = (
20384 
    None, # 0
20385 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20386 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
20387 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
20388 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
20389 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
20390 
  )
20391 
 
20392 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
20393 
    self.settlementId = settlementId
20394 
    self.settlementDate = settlementDate
20395 
    self.transactionDateFrom = transactionDateFrom
20396 
    self.transactionDateTo = transactionDateTo
20397 
    self.amount = amount
20398 
 
20399 
  def read(self, iprot):
20400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20402 
      return
20403 
    iprot.readStructBegin()
20404 
    while True:
20405 
      (fname, ftype, fid) = iprot.readFieldBegin()
20406 
      if ftype == TType.STOP:
20407 
        break
20408 
      if fid == 1:
20409 
        if ftype == TType.I64:
20410 
          self.settlementId = iprot.readI64();
20411 
        else:
20412 
          iprot.skip(ftype)
20413 
      elif fid == 2:
20414 
        if ftype == TType.I64:
20415 
          self.settlementDate = iprot.readI64();
20416 
        else:
20417 
          iprot.skip(ftype)
20418 
      elif fid == 3:
20419 
        if ftype == TType.I64:
20420 
          self.transactionDateFrom = iprot.readI64();
20421 
        else:
20422 
          iprot.skip(ftype)
20423 
      elif fid == 4:
20424 
        if ftype == TType.I64:
20425 
          self.transactionDateTo = iprot.readI64();
20426 
        else:
20427 
          iprot.skip(ftype)
20428 
      elif fid == 5:
20429 
        if ftype == TType.DOUBLE:
20430 
          self.amount = iprot.readDouble();
20431 
        else:
20432 
          iprot.skip(ftype)
20433 
      else:
20434 
        iprot.skip(ftype)
20435 
      iprot.readFieldEnd()
20436 
    iprot.readStructEnd()
20437 
 
20438 
  def write(self, oprot):
20439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20441 
      return
20442 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
20443 
    if self.settlementId is not None:
20444 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20445 
      oprot.writeI64(self.settlementId)
20446 
      oprot.writeFieldEnd()
20447 
    if self.settlementDate is not None:
20448 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
20449 
      oprot.writeI64(self.settlementDate)
20450 
      oprot.writeFieldEnd()
20451 
    if self.transactionDateFrom is not None:
20452 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
20453 
      oprot.writeI64(self.transactionDateFrom)
20454 
      oprot.writeFieldEnd()
20455 
    if self.transactionDateTo is not None:
20456 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
20457 
      oprot.writeI64(self.transactionDateTo)
20458 
      oprot.writeFieldEnd()
20459 
    if self.amount is not None:
20460 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
20461 
      oprot.writeDouble(self.amount)
20462 
      oprot.writeFieldEnd()
20463 
    oprot.writeFieldStop()
20464 
    oprot.writeStructEnd()
20465 
 
20466 
  def validate(self):
20467 
    return
20468 
 
20469 
 
20470 
  def __repr__(self):
20471 
    L = ['%s=%r' % (key, value)
20472 
      for key, value in self.__dict__.iteritems()]
20473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20474 
 
20475 
  def __eq__(self, other):
20476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20477 
 
20478 
  def __ne__(self, other):
20479 
    return not (self == other)
20480 
 
20481 
class saveEBSSettlementSummary_result:
20482 
  """
20483 
  Attributes:
20484 
   - ex
20485 
  """
20486 
 
20487 
  thrift_spec = (
20488 
    None, # 0
20489 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20490 
  )
20491 
 
20492 
  def __init__(self, ex=None,):
20493 
    self.ex = ex
20494 
 
20495 
  def read(self, iprot):
20496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20498 
      return
20499 
    iprot.readStructBegin()
20500 
    while True:
20501 
      (fname, ftype, fid) = iprot.readFieldBegin()
20502 
      if ftype == TType.STOP:
20503 
        break
20504 
      if fid == 1:
20505 
        if ftype == TType.STRUCT:
20506 
          self.ex = TransactionServiceException()
20507 
          self.ex.read(iprot)
20508 
        else:
20509 
          iprot.skip(ftype)
20510 
      else:
20511 
        iprot.skip(ftype)
20512 
      iprot.readFieldEnd()
20513 
    iprot.readStructEnd()
20514 
 
20515 
  def write(self, oprot):
20516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20518 
      return
20519 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
20520 
    if self.ex is not None:
20521 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20522 
      self.ex.write(oprot)
20523 
      oprot.writeFieldEnd()
20524 
    oprot.writeFieldStop()
20525 
    oprot.writeStructEnd()
20526 
 
20527 
  def validate(self):
20528 
    return
20529 
 
20530 
 
20531 
  def __repr__(self):
20532 
    L = ['%s=%r' % (key, value)
20533 
      for key, value in self.__dict__.iteritems()]
20534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20535 
 
20536 
  def __eq__(self, other):
20537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20538 
 
20539 
  def __ne__(self, other):
20540 
    return not (self == other)
20541 
 
5189 varun.gupt 20542 
class getSettlementForReferenceId_args:
4600 varun.gupt 20543 
  """
20544 
  Attributes:
5189 varun.gupt 20545 
   - referenceId
20546 
   - isRefund
4600 varun.gupt 20547 
  """
20548 
 
20549 
  thrift_spec = (
20550 
    None, # 0
5189 varun.gupt 20551 
    (1, TType.I64, 'referenceId', None, None, ), # 1
20552 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 20553 
  )
20554 
 
5189 varun.gupt 20555 
  def __init__(self, referenceId=None, isRefund=None,):
20556 
    self.referenceId = referenceId
20557 
    self.isRefund = isRefund
4600 varun.gupt 20558 
 
20559 
  def read(self, iprot):
20560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20562 
      return
20563 
    iprot.readStructBegin()
20564 
    while True:
20565 
      (fname, ftype, fid) = iprot.readFieldBegin()
20566 
      if ftype == TType.STOP:
20567 
        break
20568 
      if fid == 1:
20569 
        if ftype == TType.I64:
5189 varun.gupt 20570 
          self.referenceId = iprot.readI64();
4600 varun.gupt 20571 
        else:
20572 
          iprot.skip(ftype)
5189 varun.gupt 20573 
      elif fid == 2:
20574 
        if ftype == TType.BOOL:
20575 
          self.isRefund = iprot.readBool();
20576 
        else:
20577 
          iprot.skip(ftype)
4600 varun.gupt 20578 
      else:
20579 
        iprot.skip(ftype)
20580 
      iprot.readFieldEnd()
20581 
    iprot.readStructEnd()
20582 
 
20583 
  def write(self, oprot):
20584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20586 
      return
5189 varun.gupt 20587 
    oprot.writeStructBegin('getSettlementForReferenceId_args')
20588 
    if self.referenceId is not None:
20589 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
20590 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 20591 
      oprot.writeFieldEnd()
5189 varun.gupt 20592 
    if self.isRefund is not None:
20593 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
20594 
      oprot.writeBool(self.isRefund)
20595 
      oprot.writeFieldEnd()
4600 varun.gupt 20596 
    oprot.writeFieldStop()
20597 
    oprot.writeStructEnd()
20598 
 
20599 
  def validate(self):
20600 
    return
20601 
 
20602 
 
20603 
  def __repr__(self):
20604 
    L = ['%s=%r' % (key, value)
20605 
      for key, value in self.__dict__.iteritems()]
20606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20607 
 
20608 
  def __eq__(self, other):
20609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20610 
 
20611 
  def __ne__(self, other):
20612 
    return not (self == other)
20613 
 
5189 varun.gupt 20614 
class getSettlementForReferenceId_result:
4600 varun.gupt 20615 
  """
20616 
  Attributes:
20617 
   - success
20618 
   - ex
20619 
  """
20620 
 
20621 
  thrift_spec = (
20622 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
20623 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20624 
  )
20625 
 
20626 
  def __init__(self, success=None, ex=None,):
20627 
    self.success = success
20628 
    self.ex = ex
20629 
 
20630 
  def read(self, iprot):
20631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20633 
      return
20634 
    iprot.readStructBegin()
20635 
    while True:
20636 
      (fname, ftype, fid) = iprot.readFieldBegin()
20637 
      if ftype == TType.STOP:
20638 
        break
20639 
      if fid == 0:
20640 
        if ftype == TType.STRUCT:
20641 
          self.success = PaymentSettlement()
20642 
          self.success.read(iprot)
20643 
        else:
20644 
          iprot.skip(ftype)
20645 
      elif fid == 1:
20646 
        if ftype == TType.STRUCT:
20647 
          self.ex = TransactionServiceException()
20648 
          self.ex.read(iprot)
20649 
        else:
20650 
          iprot.skip(ftype)
20651 
      else:
20652 
        iprot.skip(ftype)
20653 
      iprot.readFieldEnd()
20654 
    iprot.readStructEnd()
20655 
 
20656 
  def write(self, oprot):
20657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20659 
      return
5189 varun.gupt 20660 
    oprot.writeStructBegin('getSettlementForReferenceId_result')
4600 varun.gupt 20661 
    if self.success is not None:
20662 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20663 
      self.success.write(oprot)
20664 
      oprot.writeFieldEnd()
20665 
    if self.ex is not None:
20666 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20667 
      self.ex.write(oprot)
20668 
      oprot.writeFieldEnd()
20669 
    oprot.writeFieldStop()
20670 
    oprot.writeStructEnd()
20671 
 
20672 
  def validate(self):
20673 
    return
20674 
 
20675 
 
20676 
  def __repr__(self):
20677 
    L = ['%s=%r' % (key, value)
20678 
      for key, value in self.__dict__.iteritems()]
20679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20680 
 
20681 
  def __eq__(self, other):
20682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20683 
 
20684 
  def __ne__(self, other):
20685 
    return not (self == other)
20686 
 
20687 
class getEBSSettlementSummaries_args:
20688 
 
20689 
  thrift_spec = (
20690 
  )
20691 
 
20692 
  def read(self, iprot):
20693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20695 
      return
20696 
    iprot.readStructBegin()
20697 
    while True:
20698 
      (fname, ftype, fid) = iprot.readFieldBegin()
20699 
      if ftype == TType.STOP:
20700 
        break
20701 
      else:
20702 
        iprot.skip(ftype)
20703 
      iprot.readFieldEnd()
20704 
    iprot.readStructEnd()
20705 
 
20706 
  def write(self, oprot):
20707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20709 
      return
20710 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
20711 
    oprot.writeFieldStop()
20712 
    oprot.writeStructEnd()
20713 
 
20714 
  def validate(self):
20715 
    return
20716 
 
20717 
 
20718 
  def __repr__(self):
20719 
    L = ['%s=%r' % (key, value)
20720 
      for key, value in self.__dict__.iteritems()]
20721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20722 
 
20723 
  def __eq__(self, other):
20724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20725 
 
20726 
  def __ne__(self, other):
20727 
    return not (self == other)
20728 
 
20729 
class getEBSSettlementSummaries_result:
20730 
  """
20731 
  Attributes:
20732 
   - success
20733 
   - ex
20734 
  """
20735 
 
20736 
  thrift_spec = (
20737 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
20738 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20739 
  )
20740 
 
20741 
  def __init__(self, success=None, ex=None,):
20742 
    self.success = success
20743 
    self.ex = ex
20744 
 
20745 
  def read(self, iprot):
20746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20748 
      return
20749 
    iprot.readStructBegin()
20750 
    while True:
20751 
      (fname, ftype, fid) = iprot.readFieldBegin()
20752 
      if ftype == TType.STOP:
20753 
        break
20754 
      if fid == 0:
20755 
        if ftype == TType.MAP:
20756 
          self.success = {}
5031 varun.gupt 20757 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20758 
          for _i466 in xrange(_size462):
20759 
            _key467 = iprot.readI64();
20760 
            _val468 = iprot.readString();
20761 
            self.success[_key467] = _val468
4600 varun.gupt 20762 
          iprot.readMapEnd()
20763 
        else:
20764 
          iprot.skip(ftype)
20765 
      elif fid == 1:
20766 
        if ftype == TType.STRUCT:
20767 
          self.ex = TransactionServiceException()
20768 
          self.ex.read(iprot)
20769 
        else:
20770 
          iprot.skip(ftype)
20771 
      else:
20772 
        iprot.skip(ftype)
20773 
      iprot.readFieldEnd()
20774 
    iprot.readStructEnd()
20775 
 
20776 
  def write(self, oprot):
20777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20779 
      return
20780 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
20781 
    if self.success is not None:
20782 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20783 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
5031 varun.gupt 20784 
      for kiter469,viter470 in self.success.items():
20785 
        oprot.writeI64(kiter469)
20786 
        oprot.writeString(viter470)
4600 varun.gupt 20787 
      oprot.writeMapEnd()
20788 
      oprot.writeFieldEnd()
20789 
    if self.ex is not None:
20790 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20791 
      self.ex.write(oprot)
20792 
      oprot.writeFieldEnd()
20793 
    oprot.writeFieldStop()
20794 
    oprot.writeStructEnd()
20795 
 
20796 
  def validate(self):
20797 
    return
20798 
 
20799 
 
20800 
  def __repr__(self):
20801 
    L = ['%s=%r' % (key, value)
20802 
      for key, value in self.__dict__.iteritems()]
20803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20804 
 
20805 
  def __eq__(self, other):
20806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20807 
 
20808 
  def __ne__(self, other):
20809 
    return not (self == other)
20810 
 
20811 
class markEBSSettlementUploaded_args:
20812 
  """
20813 
  Attributes:
20814 
   - settlementId
20815 
  """
20816 
 
20817 
  thrift_spec = (
20818 
    None, # 0
20819 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20820 
  )
20821 
 
20822 
  def __init__(self, settlementId=None,):
20823 
    self.settlementId = settlementId
20824 
 
20825 
  def read(self, iprot):
20826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20828 
      return
20829 
    iprot.readStructBegin()
20830 
    while True:
20831 
      (fname, ftype, fid) = iprot.readFieldBegin()
20832 
      if ftype == TType.STOP:
20833 
        break
20834 
      if fid == 1:
20835 
        if ftype == TType.I64:
20836 
          self.settlementId = iprot.readI64();
20837 
        else:
20838 
          iprot.skip(ftype)
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('markEBSSettlementUploaded_args')
20849 
    if self.settlementId is not None:
20850 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20851 
      oprot.writeI64(self.settlementId)
20852 
      oprot.writeFieldEnd()
20853 
    oprot.writeFieldStop()
20854 
    oprot.writeStructEnd()
20855 
 
20856 
  def validate(self):
20857 
    return
20858 
 
20859 
 
20860 
  def __repr__(self):
20861 
    L = ['%s=%r' % (key, value)
20862 
      for key, value in self.__dict__.iteritems()]
20863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20864 
 
20865 
  def __eq__(self, other):
20866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20867 
 
20868 
  def __ne__(self, other):
20869 
    return not (self == other)
20870 
 
20871 
class markEBSSettlementUploaded_result:
20872 
  """
20873 
  Attributes:
20874 
   - ex
20875 
  """
20876 
 
20877 
  thrift_spec = (
20878 
    None, # 0
20879 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20880 
  )
20881 
 
20882 
  def __init__(self, ex=None,):
20883 
    self.ex = ex
20884 
 
20885 
  def read(self, iprot):
20886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20888 
      return
20889 
    iprot.readStructBegin()
20890 
    while True:
20891 
      (fname, ftype, fid) = iprot.readFieldBegin()
20892 
      if ftype == TType.STOP:
20893 
        break
20894 
      if fid == 1:
20895 
        if ftype == TType.STRUCT:
20896 
          self.ex = TransactionServiceException()
20897 
          self.ex.read(iprot)
20898 
        else:
20899 
          iprot.skip(ftype)
20900 
      else:
20901 
        iprot.skip(ftype)
20902 
      iprot.readFieldEnd()
20903 
    iprot.readStructEnd()
20904 
 
20905 
  def write(self, oprot):
20906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20908 
      return
20909 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
20910 
    if self.ex is not None:
20911 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20912 
      self.ex.write(oprot)
20913 
      oprot.writeFieldEnd()
20914 
    oprot.writeFieldStop()
20915 
    oprot.writeStructEnd()
20916 
 
20917 
  def validate(self):
20918 
    return
20919 
 
20920 
 
20921 
  def __repr__(self):
20922 
    L = ['%s=%r' % (key, value)
20923 
      for key, value in self.__dict__.iteritems()]
20924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20925 
 
20926 
  def __eq__(self, other):
20927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20928 
 
20929 
  def __ne__(self, other):
20930 
    return not (self == other)
20931 
 
20932 
class getEBSSettlementDate_args:
20933 
  """
20934 
  Attributes:
20935 
   - settlementId
20936 
  """
20937 
 
20938 
  thrift_spec = (
20939 
    None, # 0
20940 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20941 
  )
20942 
 
20943 
  def __init__(self, settlementId=None,):
20944 
    self.settlementId = settlementId
20945 
 
20946 
  def read(self, iprot):
20947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20949 
      return
20950 
    iprot.readStructBegin()
20951 
    while True:
20952 
      (fname, ftype, fid) = iprot.readFieldBegin()
20953 
      if ftype == TType.STOP:
20954 
        break
20955 
      if fid == 1:
20956 
        if ftype == TType.I64:
20957 
          self.settlementId = iprot.readI64();
20958 
        else:
20959 
          iprot.skip(ftype)
20960 
      else:
20961 
        iprot.skip(ftype)
20962 
      iprot.readFieldEnd()
20963 
    iprot.readStructEnd()
20964 
 
20965 
  def write(self, oprot):
20966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20968 
      return
20969 
    oprot.writeStructBegin('getEBSSettlementDate_args')
20970 
    if self.settlementId is not None:
20971 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20972 
      oprot.writeI64(self.settlementId)
20973 
      oprot.writeFieldEnd()
20974 
    oprot.writeFieldStop()
20975 
    oprot.writeStructEnd()
20976 
 
20977 
  def validate(self):
20978 
    return
20979 
 
20980 
 
20981 
  def __repr__(self):
20982 
    L = ['%s=%r' % (key, value)
20983 
      for key, value in self.__dict__.iteritems()]
20984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20985 
 
20986 
  def __eq__(self, other):
20987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20988 
 
20989 
  def __ne__(self, other):
20990 
    return not (self == other)
20991 
 
20992 
class getEBSSettlementDate_result:
20993 
  """
20994 
  Attributes:
20995 
   - success
20996 
   - ex
20997 
  """
20998 
 
20999 
  thrift_spec = (
21000 
    (0, TType.I64, 'success', None, None, ), # 0
21001 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21002 
  )
21003 
 
21004 
  def __init__(self, success=None, ex=None,):
21005 
    self.success = success
21006 
    self.ex = ex
21007 
 
21008 
  def read(self, iprot):
21009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21011 
      return
21012 
    iprot.readStructBegin()
21013 
    while True:
21014 
      (fname, ftype, fid) = iprot.readFieldBegin()
21015 
      if ftype == TType.STOP:
21016 
        break
21017 
      if fid == 0:
21018 
        if ftype == TType.I64:
21019 
          self.success = iprot.readI64();
21020 
        else:
21021 
          iprot.skip(ftype)
21022 
      elif fid == 1:
21023 
        if ftype == TType.STRUCT:
21024 
          self.ex = TransactionServiceException()
21025 
          self.ex.read(iprot)
21026 
        else:
21027 
          iprot.skip(ftype)
21028 
      else:
21029 
        iprot.skip(ftype)
21030 
      iprot.readFieldEnd()
21031 
    iprot.readStructEnd()
21032 
 
21033 
  def write(self, oprot):
21034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21036 
      return
21037 
    oprot.writeStructBegin('getEBSSettlementDate_result')
21038 
    if self.success is not None:
21039 
      oprot.writeFieldBegin('success', TType.I64, 0)
21040 
      oprot.writeI64(self.success)
21041 
      oprot.writeFieldEnd()
21042 
    if self.ex is not None:
21043 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21044 
      self.ex.write(oprot)
21045 
      oprot.writeFieldEnd()
21046 
    oprot.writeFieldStop()
21047 
    oprot.writeStructEnd()
21048 
 
21049 
  def validate(self):
21050 
    return
21051 
 
21052 
 
21053 
  def __repr__(self):
21054 
    L = ['%s=%r' % (key, value)
21055 
      for key, value in self.__dict__.iteritems()]
21056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21057 
 
21058 
  def __eq__(self, other):
21059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21060 
 
21061 
  def __ne__(self, other):
21062 
    return not (self == other)
4715 varun.gupt 21063 
 
21064 
class getSettlementsByDate_args:
21065 
  """
21066 
  Attributes:
21067 
   - settlementDateFrom
21068 
   - settlementDateTo
21069 
   - isRefund
21070 
  """
21071 
 
21072 
  thrift_spec = (
21073 
    None, # 0
21074 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
21075 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
21076 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
21077 
  )
21078 
 
21079 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
21080 
    self.settlementDateFrom = settlementDateFrom
21081 
    self.settlementDateTo = settlementDateTo
21082 
    self.isRefund = isRefund
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.settlementDateFrom = iprot.readI64();
21096 
        else:
21097 
          iprot.skip(ftype)
21098 
      elif fid == 2:
21099 
        if ftype == TType.I64:
21100 
          self.settlementDateTo = iprot.readI64();
21101 
        else:
21102 
          iprot.skip(ftype)
21103 
      elif fid == 3:
21104 
        if ftype == TType.BOOL:
21105 
          self.isRefund = iprot.readBool();
21106 
        else:
21107 
          iprot.skip(ftype)
21108 
      else:
21109 
        iprot.skip(ftype)
21110 
      iprot.readFieldEnd()
21111 
    iprot.readStructEnd()
21112 
 
21113 
  def write(self, oprot):
21114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21116 
      return
21117 
    oprot.writeStructBegin('getSettlementsByDate_args')
21118 
    if self.settlementDateFrom is not None:
21119 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
21120 
      oprot.writeI64(self.settlementDateFrom)
21121 
      oprot.writeFieldEnd()
21122 
    if self.settlementDateTo is not None:
21123 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
21124 
      oprot.writeI64(self.settlementDateTo)
21125 
      oprot.writeFieldEnd()
21126 
    if self.isRefund is not None:
21127 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
21128 
      oprot.writeBool(self.isRefund)
21129 
      oprot.writeFieldEnd()
21130 
    oprot.writeFieldStop()
21131 
    oprot.writeStructEnd()
21132 
 
21133 
  def validate(self):
21134 
    return
21135 
 
21136 
 
21137 
  def __repr__(self):
21138 
    L = ['%s=%r' % (key, value)
21139 
      for key, value in self.__dict__.iteritems()]
21140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21141 
 
21142 
  def __eq__(self, other):
21143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21144 
 
21145 
  def __ne__(self, other):
21146 
    return not (self == other)
21147 
 
21148 
class getSettlementsByDate_result:
21149 
  """
21150 
  Attributes:
21151 
   - success
21152 
   - ex
21153 
  """
21154 
 
21155 
  thrift_spec = (
21156 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
21157 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21158 
  )
21159 
 
21160 
  def __init__(self, success=None, ex=None,):
21161 
    self.success = success
21162 
    self.ex = ex
21163 
 
21164 
  def read(self, iprot):
21165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21167 
      return
21168 
    iprot.readStructBegin()
21169 
    while True:
21170 
      (fname, ftype, fid) = iprot.readFieldBegin()
21171 
      if ftype == TType.STOP:
21172 
        break
21173 
      if fid == 0:
21174 
        if ftype == TType.LIST:
21175 
          self.success = []
5031 varun.gupt 21176 
          (_etype474, _size471) = iprot.readListBegin()
21177 
          for _i475 in xrange(_size471):
21178 
            _elem476 = PaymentSettlement()
21179 
            _elem476.read(iprot)
21180 
            self.success.append(_elem476)
4715 varun.gupt 21181 
          iprot.readListEnd()
21182 
        else:
21183 
          iprot.skip(ftype)
21184 
      elif fid == 1:
21185 
        if ftype == TType.STRUCT:
21186 
          self.ex = TransactionServiceException()
21187 
          self.ex.read(iprot)
21188 
        else:
21189 
          iprot.skip(ftype)
21190 
      else:
21191 
        iprot.skip(ftype)
21192 
      iprot.readFieldEnd()
21193 
    iprot.readStructEnd()
21194 
 
21195 
  def write(self, oprot):
21196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21198 
      return
21199 
    oprot.writeStructBegin('getSettlementsByDate_result')
21200 
    if self.success is not None:
21201 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21202 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 21203 
      for iter477 in self.success:
21204 
        iter477.write(oprot)
4715 varun.gupt 21205 
      oprot.writeListEnd()
21206 
      oprot.writeFieldEnd()
21207 
    if self.ex is not None:
21208 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21209 
      self.ex.write(oprot)
21210 
      oprot.writeFieldEnd()
21211 
    oprot.writeFieldStop()
21212 
    oprot.writeStructEnd()
21213 
 
21214 
  def validate(self):
21215 
    return
21216 
 
21217 
 
21218 
  def __repr__(self):
21219 
    L = ['%s=%r' % (key, value)
21220 
      for key, value in self.__dict__.iteritems()]
21221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21222 
 
21223 
  def __eq__(self, other):
21224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21225 
 
21226 
  def __ne__(self, other):
21227 
    return not (self == other)
21228 
 
21229 
class getReshippedOrderIds_args:
21230 
  """
21231 
  Attributes:
21232 
   - orderIds
21233 
  """
21234 
 
21235 
  thrift_spec = (
21236 
    None, # 0
21237 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
21238 
  )
21239 
 
21240 
  def __init__(self, orderIds=None,):
21241 
    self.orderIds = orderIds
21242 
 
21243 
  def read(self, iprot):
21244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21246 
      return
21247 
    iprot.readStructBegin()
21248 
    while True:
21249 
      (fname, ftype, fid) = iprot.readFieldBegin()
21250 
      if ftype == TType.STOP:
21251 
        break
21252 
      if fid == 1:
21253 
        if ftype == TType.LIST:
21254 
          self.orderIds = []
5031 varun.gupt 21255 
          (_etype481, _size478) = iprot.readListBegin()
21256 
          for _i482 in xrange(_size478):
21257 
            _elem483 = iprot.readI64();
21258 
            self.orderIds.append(_elem483)
4715 varun.gupt 21259 
          iprot.readListEnd()
21260 
        else:
21261 
          iprot.skip(ftype)
21262 
      else:
21263 
        iprot.skip(ftype)
21264 
      iprot.readFieldEnd()
21265 
    iprot.readStructEnd()
21266 
 
21267 
  def write(self, oprot):
21268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21270 
      return
21271 
    oprot.writeStructBegin('getReshippedOrderIds_args')
21272 
    if self.orderIds is not None:
21273 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
21274 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5031 varun.gupt 21275 
      for iter484 in self.orderIds:
21276 
        oprot.writeI64(iter484)
4715 varun.gupt 21277 
      oprot.writeListEnd()
21278 
      oprot.writeFieldEnd()
21279 
    oprot.writeFieldStop()
21280 
    oprot.writeStructEnd()
21281 
 
21282 
  def validate(self):
21283 
    return
21284 
 
21285 
 
21286 
  def __repr__(self):
21287 
    L = ['%s=%r' % (key, value)
21288 
      for key, value in self.__dict__.iteritems()]
21289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21290 
 
21291 
  def __eq__(self, other):
21292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21293 
 
21294 
  def __ne__(self, other):
21295 
    return not (self == other)
21296 
 
21297 
class getReshippedOrderIds_result:
21298 
  """
21299 
  Attributes:
21300 
   - success
21301 
   - ex
21302 
  """
21303 
 
21304 
  thrift_spec = (
21305 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21306 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21307 
  )
21308 
 
21309 
  def __init__(self, success=None, ex=None,):
21310 
    self.success = success
21311 
    self.ex = ex
21312 
 
21313 
  def read(self, iprot):
21314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21316 
      return
21317 
    iprot.readStructBegin()
21318 
    while True:
21319 
      (fname, ftype, fid) = iprot.readFieldBegin()
21320 
      if ftype == TType.STOP:
21321 
        break
21322 
      if fid == 0:
21323 
        if ftype == TType.LIST:
21324 
          self.success = []
5031 varun.gupt 21325 
          (_etype488, _size485) = iprot.readListBegin()
21326 
          for _i489 in xrange(_size485):
21327 
            _elem490 = iprot.readI64();
21328 
            self.success.append(_elem490)
4715 varun.gupt 21329 
          iprot.readListEnd()
21330 
        else:
21331 
          iprot.skip(ftype)
21332 
      elif fid == 1:
21333 
        if ftype == TType.STRUCT:
21334 
          self.ex = TransactionServiceException()
21335 
          self.ex.read(iprot)
21336 
        else:
21337 
          iprot.skip(ftype)
21338 
      else:
21339 
        iprot.skip(ftype)
21340 
      iprot.readFieldEnd()
21341 
    iprot.readStructEnd()
21342 
 
21343 
  def write(self, oprot):
21344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21346 
      return
21347 
    oprot.writeStructBegin('getReshippedOrderIds_result')
21348 
    if self.success is not None:
21349 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21350 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 21351 
      for iter491 in self.success:
21352 
        oprot.writeI64(iter491)
4715 varun.gupt 21353 
      oprot.writeListEnd()
21354 
      oprot.writeFieldEnd()
21355 
    if self.ex is not None:
21356 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21357 
      self.ex.write(oprot)
21358 
      oprot.writeFieldEnd()
21359 
    oprot.writeFieldStop()
21360 
    oprot.writeStructEnd()
21361 
 
21362 
  def validate(self):
21363 
    return
21364 
 
21365 
 
21366 
  def __repr__(self):
21367 
    L = ['%s=%r' % (key, value)
21368 
      for key, value in self.__dict__.iteritems()]
21369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21370 
 
21371 
  def __eq__(self, other):
21372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21373 
 
21374 
  def __ne__(self, other):
21375 
    return not (self == other)
4757 mandeep.dh 21376 
 
4875 varun.gupt 21377 
class getOrdersWhereVendorNotPaid_args:
21378 
  """
21379 
  Attributes:
21380 
   - vendorId
21381 
  """
21382 
 
21383 
  thrift_spec = (
21384 
    None, # 0
21385 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21386 
  )
21387 
 
21388 
  def __init__(self, vendorId=None,):
21389 
    self.vendorId = vendorId
21390 
 
21391 
  def read(self, iprot):
21392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21394 
      return
21395 
    iprot.readStructBegin()
21396 
    while True:
21397 
      (fname, ftype, fid) = iprot.readFieldBegin()
21398 
      if ftype == TType.STOP:
21399 
        break
21400 
      if fid == 1:
21401 
        if ftype == TType.I64:
21402 
          self.vendorId = iprot.readI64();
21403 
        else:
21404 
          iprot.skip(ftype)
21405 
      else:
21406 
        iprot.skip(ftype)
21407 
      iprot.readFieldEnd()
21408 
    iprot.readStructEnd()
21409 
 
21410 
  def write(self, oprot):
21411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21413 
      return
21414 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_args')
21415 
    if self.vendorId is not None:
21416 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21417 
      oprot.writeI64(self.vendorId)
21418 
      oprot.writeFieldEnd()
21419 
    oprot.writeFieldStop()
21420 
    oprot.writeStructEnd()
21421 
 
21422 
  def validate(self):
21423 
    return
21424 
 
21425 
 
21426 
  def __repr__(self):
21427 
    L = ['%s=%r' % (key, value)
21428 
      for key, value in self.__dict__.iteritems()]
21429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21430 
 
21431 
  def __eq__(self, other):
21432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21433 
 
21434 
  def __ne__(self, other):
21435 
    return not (self == other)
21436 
 
21437 
class getOrdersWhereVendorNotPaid_result:
21438 
  """
21439 
  Attributes:
21440 
   - success
21441 
   - ex
21442 
  """
21443 
 
21444 
  thrift_spec = (
21445 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21446 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21447 
  )
21448 
 
21449 
  def __init__(self, success=None, ex=None,):
21450 
    self.success = success
21451 
    self.ex = ex
21452 
 
21453 
  def read(self, iprot):
21454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21456 
      return
21457 
    iprot.readStructBegin()
21458 
    while True:
21459 
      (fname, ftype, fid) = iprot.readFieldBegin()
21460 
      if ftype == TType.STOP:
21461 
        break
21462 
      if fid == 0:
21463 
        if ftype == TType.LIST:
21464 
          self.success = []
5238 mandeep.dh 21465 
          (_etype495, _size492) = iprot.readListBegin()
21466 
          for _i496 in xrange(_size492):
21467 
            _elem497 = Order()
21468 
            _elem497.read(iprot)
21469 
            self.success.append(_elem497)
4875 varun.gupt 21470 
          iprot.readListEnd()
21471 
        else:
21472 
          iprot.skip(ftype)
21473 
      elif fid == 1:
21474 
        if ftype == TType.STRUCT:
21475 
          self.ex = TransactionServiceException()
21476 
          self.ex.read(iprot)
21477 
        else:
21478 
          iprot.skip(ftype)
21479 
      else:
21480 
        iprot.skip(ftype)
21481 
      iprot.readFieldEnd()
21482 
    iprot.readStructEnd()
21483 
 
21484 
  def write(self, oprot):
21485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21487 
      return
21488 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_result')
21489 
    if self.success is not None:
21490 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21491 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5238 mandeep.dh 21492 
      for iter498 in self.success:
21493 
        iter498.write(oprot)
4875 varun.gupt 21494 
      oprot.writeListEnd()
21495 
      oprot.writeFieldEnd()
21496 
    if self.ex is not None:
21497 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21498 
      self.ex.write(oprot)
21499 
      oprot.writeFieldEnd()
21500 
    oprot.writeFieldStop()
21501 
    oprot.writeStructEnd()
21502 
 
21503 
  def validate(self):
21504 
    return
21505 
 
21506 
 
21507 
  def __repr__(self):
21508 
    L = ['%s=%r' % (key, value)
21509 
      for key, value in self.__dict__.iteritems()]
21510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21511 
 
21512 
  def __eq__(self, other):
21513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21514 
 
21515 
  def __ne__(self, other):
21516 
    return not (self == other)
5031 varun.gupt 21517 
 
21518 
class getStatusDistributionOfOrders_args:
21519 
  """
21520 
  Attributes:
21521 
   - startDate
21522 
   - endDate
21523 
  """
21524 
 
21525 
  thrift_spec = (
21526 
    None, # 0
21527 
    (1, TType.I64, 'startDate', None, None, ), # 1
21528 
    (2, TType.I64, 'endDate', None, None, ), # 2
21529 
  )
21530 
 
21531 
  def __init__(self, startDate=None, endDate=None,):
21532 
    self.startDate = startDate
21533 
    self.endDate = endDate
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.I64:
21546 
          self.startDate = iprot.readI64();
21547 
        else:
21548 
          iprot.skip(ftype)
21549 
      elif fid == 2:
21550 
        if ftype == TType.I64:
21551 
          self.endDate = iprot.readI64();
21552 
        else:
21553 
          iprot.skip(ftype)
21554 
      else:
21555 
        iprot.skip(ftype)
21556 
      iprot.readFieldEnd()
21557 
    iprot.readStructEnd()
21558 
 
21559 
  def write(self, oprot):
21560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21562 
      return
21563 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
21564 
    if self.startDate is not None:
21565 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
21566 
      oprot.writeI64(self.startDate)
21567 
      oprot.writeFieldEnd()
21568 
    if self.endDate is not None:
21569 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
21570 
      oprot.writeI64(self.endDate)
21571 
      oprot.writeFieldEnd()
21572 
    oprot.writeFieldStop()
21573 
    oprot.writeStructEnd()
21574 
 
21575 
  def validate(self):
21576 
    return
21577 
 
21578 
 
21579 
  def __repr__(self):
21580 
    L = ['%s=%r' % (key, value)
21581 
      for key, value in self.__dict__.iteritems()]
21582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21583 
 
21584 
  def __eq__(self, other):
21585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21586 
 
21587 
  def __ne__(self, other):
21588 
    return not (self == other)
21589 
 
21590 
class getStatusDistributionOfOrders_result:
21591 
  """
21592 
  Attributes:
21593 
   - success
21594 
   - ex
21595 
  """
21596 
 
21597 
  thrift_spec = (
21598 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
21599 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21600 
  )
21601 
 
21602 
  def __init__(self, success=None, ex=None,):
21603 
    self.success = success
21604 
    self.ex = ex
21605 
 
21606 
  def read(self, iprot):
21607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21609 
      return
21610 
    iprot.readStructBegin()
21611 
    while True:
21612 
      (fname, ftype, fid) = iprot.readFieldBegin()
21613 
      if ftype == TType.STOP:
21614 
        break
21615 
      if fid == 0:
21616 
        if ftype == TType.MAP:
21617 
          self.success = {}
5238 mandeep.dh 21618 
          (_ktype500, _vtype501, _size499 ) = iprot.readMapBegin()
21619 
          for _i503 in xrange(_size499):
21620 
            _key504 = iprot.readI64();
21621 
            _val505 = iprot.readI64();
21622 
            self.success[_key504] = _val505
5031 varun.gupt 21623 
          iprot.readMapEnd()
21624 
        else:
21625 
          iprot.skip(ftype)
21626 
      elif fid == 1:
21627 
        if ftype == TType.STRUCT:
21628 
          self.ex = TransactionServiceException()
21629 
          self.ex.read(iprot)
21630 
        else:
21631 
          iprot.skip(ftype)
21632 
      else:
21633 
        iprot.skip(ftype)
21634 
      iprot.readFieldEnd()
21635 
    iprot.readStructEnd()
21636 
 
21637 
  def write(self, oprot):
21638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21640 
      return
21641 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
21642 
    if self.success is not None:
21643 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21644 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5238 mandeep.dh 21645 
      for kiter506,viter507 in self.success.items():
21646 
        oprot.writeI64(kiter506)
21647 
        oprot.writeI64(viter507)
5031 varun.gupt 21648 
      oprot.writeMapEnd()
21649 
      oprot.writeFieldEnd()
21650 
    if self.ex is not None:
21651 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21652 
      self.ex.write(oprot)
21653 
      oprot.writeFieldEnd()
21654 
    oprot.writeFieldStop()
21655 
    oprot.writeStructEnd()
21656 
 
21657 
  def validate(self):
21658 
    return
21659 
 
21660 
 
21661 
  def __repr__(self):
21662 
    L = ['%s=%r' % (key, value)
21663 
      for key, value in self.__dict__.iteritems()]
21664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21665 
 
21666 
  def __eq__(self, other):
21667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21668 
 
21669 
  def __ne__(self, other):
21670 
    return not (self == other)
5067 varun.gupt 21671 
 
21672 
class getOrderIdsForStatus_args:
21673 
  """
21674 
  Attributes:
21675 
   - status
21676 
   - startDatetime
21677 
   - endDatetime
21678 
  """
21679 
 
21680 
  thrift_spec = (
21681 
    None, # 0
21682 
    (1, TType.I64, 'status', None, None, ), # 1
21683 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
21684 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
21685 
  )
21686 
 
21687 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
21688 
    self.status = status
21689 
    self.startDatetime = startDatetime
21690 
    self.endDatetime = endDatetime
21691 
 
21692 
  def read(self, iprot):
21693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21695 
      return
21696 
    iprot.readStructBegin()
21697 
    while True:
21698 
      (fname, ftype, fid) = iprot.readFieldBegin()
21699 
      if ftype == TType.STOP:
21700 
        break
21701 
      if fid == 1:
21702 
        if ftype == TType.I64:
21703 
          self.status = iprot.readI64();
21704 
        else:
21705 
          iprot.skip(ftype)
21706 
      elif fid == 2:
21707 
        if ftype == TType.I64:
21708 
          self.startDatetime = iprot.readI64();
21709 
        else:
21710 
          iprot.skip(ftype)
21711 
      elif fid == 3:
21712 
        if ftype == TType.I64:
21713 
          self.endDatetime = iprot.readI64();
21714 
        else:
21715 
          iprot.skip(ftype)
21716 
      else:
21717 
        iprot.skip(ftype)
21718 
      iprot.readFieldEnd()
21719 
    iprot.readStructEnd()
21720 
 
21721 
  def write(self, oprot):
21722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21724 
      return
21725 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
21726 
    if self.status is not None:
21727 
      oprot.writeFieldBegin('status', TType.I64, 1)
21728 
      oprot.writeI64(self.status)
21729 
      oprot.writeFieldEnd()
21730 
    if self.startDatetime is not None:
21731 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
21732 
      oprot.writeI64(self.startDatetime)
21733 
      oprot.writeFieldEnd()
21734 
    if self.endDatetime is not None:
21735 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
21736 
      oprot.writeI64(self.endDatetime)
21737 
      oprot.writeFieldEnd()
21738 
    oprot.writeFieldStop()
21739 
    oprot.writeStructEnd()
21740 
 
21741 
  def validate(self):
21742 
    return
21743 
 
21744 
 
21745 
  def __repr__(self):
21746 
    L = ['%s=%r' % (key, value)
21747 
      for key, value in self.__dict__.iteritems()]
21748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21749 
 
21750 
  def __eq__(self, other):
21751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21752 
 
21753 
  def __ne__(self, other):
21754 
    return not (self == other)
21755 
 
21756 
class getOrderIdsForStatus_result:
21757 
  """
21758 
  Attributes:
21759 
   - success
21760 
   - ex
21761 
  """
21762 
 
21763 
  thrift_spec = (
21764 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21765 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21766 
  )
21767 
 
21768 
  def __init__(self, success=None, ex=None,):
21769 
    self.success = success
21770 
    self.ex = ex
21771 
 
21772 
  def read(self, iprot):
21773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21775 
      return
21776 
    iprot.readStructBegin()
21777 
    while True:
21778 
      (fname, ftype, fid) = iprot.readFieldBegin()
21779 
      if ftype == TType.STOP:
21780 
        break
21781 
      if fid == 0:
21782 
        if ftype == TType.LIST:
21783 
          self.success = []
5238 mandeep.dh 21784 
          (_etype511, _size508) = iprot.readListBegin()
21785 
          for _i512 in xrange(_size508):
21786 
            _elem513 = iprot.readI64();
21787 
            self.success.append(_elem513)
5067 varun.gupt 21788 
          iprot.readListEnd()
21789 
        else:
21790 
          iprot.skip(ftype)
21791 
      elif fid == 1:
21792 
        if ftype == TType.STRUCT:
21793 
          self.ex = TransactionServiceException()
21794 
          self.ex.read(iprot)
21795 
        else:
21796 
          iprot.skip(ftype)
21797 
      else:
21798 
        iprot.skip(ftype)
21799 
      iprot.readFieldEnd()
21800 
    iprot.readStructEnd()
21801 
 
21802 
  def write(self, oprot):
21803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21805 
      return
21806 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
21807 
    if self.success is not None:
21808 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21809 
      oprot.writeListBegin(TType.I64, len(self.success))
5238 mandeep.dh 21810 
      for iter514 in self.success:
21811 
        oprot.writeI64(iter514)
5067 varun.gupt 21812 
      oprot.writeListEnd()
21813 
      oprot.writeFieldEnd()
21814 
    if self.ex is not None:
21815 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21816 
      self.ex.write(oprot)
21817 
      oprot.writeFieldEnd()
21818 
    oprot.writeFieldStop()
21819 
    oprot.writeStructEnd()
21820 
 
21821 
  def validate(self):
21822 
    return
21823 
 
21824 
 
21825 
  def __repr__(self):
21826 
    L = ['%s=%r' % (key, value)
21827 
      for key, value in self.__dict__.iteritems()]
21828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21829 
 
21830 
  def __eq__(self, other):
21831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21832 
 
21833 
  def __ne__(self, other):
21834 
    return not (self == other)
5099 varun.gupt 21835 
 
21836 
class updateOrderAsPaidToVendor_args:
21837 
  """
21838 
  Attributes:
21839 
   - orderId
21840 
  """
21841 
 
21842 
  thrift_spec = (
21843 
    None, # 0
21844 
    (1, TType.I64, 'orderId', None, None, ), # 1
21845 
  )
21846 
 
21847 
  def __init__(self, orderId=None,):
21848 
    self.orderId = orderId
21849 
 
21850 
  def read(self, iprot):
21851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21853 
      return
21854 
    iprot.readStructBegin()
21855 
    while True:
21856 
      (fname, ftype, fid) = iprot.readFieldBegin()
21857 
      if ftype == TType.STOP:
21858 
        break
21859 
      if fid == 1:
21860 
        if ftype == TType.I64:
21861 
          self.orderId = iprot.readI64();
21862 
        else:
21863 
          iprot.skip(ftype)
21864 
      else:
21865 
        iprot.skip(ftype)
21866 
      iprot.readFieldEnd()
21867 
    iprot.readStructEnd()
21868 
 
21869 
  def write(self, oprot):
21870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21872 
      return
21873 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
21874 
    if self.orderId is not None:
21875 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21876 
      oprot.writeI64(self.orderId)
21877 
      oprot.writeFieldEnd()
21878 
    oprot.writeFieldStop()
21879 
    oprot.writeStructEnd()
21880 
 
21881 
  def validate(self):
21882 
    return
21883 
 
21884 
 
21885 
  def __repr__(self):
21886 
    L = ['%s=%r' % (key, value)
21887 
      for key, value in self.__dict__.iteritems()]
21888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21889 
 
21890 
  def __eq__(self, other):
21891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21892 
 
21893 
  def __ne__(self, other):
21894 
    return not (self == other)
21895 
 
21896 
class updateOrderAsPaidToVendor_result:
21897 
  """
21898 
  Attributes:
21899 
   - ex
21900 
  """
21901 
 
21902 
  thrift_spec = (
21903 
    None, # 0
21904 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21905 
  )
21906 
 
21907 
  def __init__(self, ex=None,):
21908 
    self.ex = ex
21909 
 
21910 
  def read(self, iprot):
21911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21913 
      return
21914 
    iprot.readStructBegin()
21915 
    while True:
21916 
      (fname, ftype, fid) = iprot.readFieldBegin()
21917 
      if ftype == TType.STOP:
21918 
        break
21919 
      if 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('updateOrderAsPaidToVendor_result')
21935 
    if self.ex is not None:
21936 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21937 
      self.ex.write(oprot)
21938 
      oprot.writeFieldEnd()
21939 
    oprot.writeFieldStop()
21940 
    oprot.writeStructEnd()
21941 
 
21942 
  def validate(self):
21943 
    return
21944 
 
21945 
 
21946 
  def __repr__(self):
21947 
    L = ['%s=%r' % (key, value)
21948 
      for key, value in self.__dict__.iteritems()]
21949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21950 
 
21951 
  def __eq__(self, other):
21952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21953 
 
21954 
  def __ne__(self, other):
21955 
    return not (self == other)
5208 varun.gupt 21956 
 
21957 
class getRefundedOrdersMarkedPaid_args:
21958 
 
21959 
  thrift_spec = (
21960 
  )
21961 
 
21962 
  def read(self, iprot):
21963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21965 
      return
21966 
    iprot.readStructBegin()
21967 
    while True:
21968 
      (fname, ftype, fid) = iprot.readFieldBegin()
21969 
      if ftype == TType.STOP:
21970 
        break
21971 
      else:
21972 
        iprot.skip(ftype)
21973 
      iprot.readFieldEnd()
21974 
    iprot.readStructEnd()
21975 
 
21976 
  def write(self, oprot):
21977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21979 
      return
21980 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
21981 
    oprot.writeFieldStop()
21982 
    oprot.writeStructEnd()
21983 
 
21984 
  def validate(self):
21985 
    return
21986 
 
21987 
 
21988 
  def __repr__(self):
21989 
    L = ['%s=%r' % (key, value)
21990 
      for key, value in self.__dict__.iteritems()]
21991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21992 
 
21993 
  def __eq__(self, other):
21994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21995 
 
21996 
  def __ne__(self, other):
21997 
    return not (self == other)
21998 
 
21999 
class getRefundedOrdersMarkedPaid_result:
22000 
  """
22001 
  Attributes:
22002 
   - success
22003 
   - ex
22004 
  """
22005 
 
22006 
  thrift_spec = (
22007 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22008 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22009 
  )
22010 
 
22011 
  def __init__(self, success=None, ex=None,):
22012 
    self.success = success
22013 
    self.ex = ex
22014 
 
22015 
  def read(self, iprot):
22016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22018 
      return
22019 
    iprot.readStructBegin()
22020 
    while True:
22021 
      (fname, ftype, fid) = iprot.readFieldBegin()
22022 
      if ftype == TType.STOP:
22023 
        break
22024 
      if fid == 0:
22025 
        if ftype == TType.LIST:
22026 
          self.success = []
5238 mandeep.dh 22027 
          (_etype518, _size515) = iprot.readListBegin()
22028 
          for _i519 in xrange(_size515):
22029 
            _elem520 = Order()
22030 
            _elem520.read(iprot)
22031 
            self.success.append(_elem520)
5208 varun.gupt 22032 
          iprot.readListEnd()
22033 
        else:
22034 
          iprot.skip(ftype)
22035 
      elif fid == 1:
22036 
        if ftype == TType.STRUCT:
22037 
          self.ex = TransactionServiceException()
22038 
          self.ex.read(iprot)
22039 
        else:
22040 
          iprot.skip(ftype)
22041 
      else:
22042 
        iprot.skip(ftype)
22043 
      iprot.readFieldEnd()
22044 
    iprot.readStructEnd()
22045 
 
22046 
  def write(self, oprot):
22047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22049 
      return
22050 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
22051 
    if self.success is not None:
22052 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22053 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5238 mandeep.dh 22054 
      for iter521 in self.success:
22055 
        iter521.write(oprot)
5208 varun.gupt 22056 
      oprot.writeListEnd()
22057 
      oprot.writeFieldEnd()
22058 
    if self.ex is not None:
22059 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22060 
      self.ex.write(oprot)
22061 
      oprot.writeFieldEnd()
22062 
    oprot.writeFieldStop()
22063 
    oprot.writeStructEnd()
22064 
 
22065 
  def validate(self):
22066 
    return
22067 
 
22068 
 
22069 
  def __repr__(self):
22070 
    L = ['%s=%r' % (key, value)
22071 
      for key, value in self.__dict__.iteritems()]
22072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22073 
 
22074 
  def __eq__(self, other):
22075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22076 
 
22077 
  def __ne__(self, other):
22078 
    return not (self == other)