Subversion Repositories SmartDukaan

Rev

Rev 5099 | Rev 5189 | 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 
 
1046 
  def getSettlementForPaymentId(self, paymentId):
1047 
    """
1048 
    Parameters:
1049 
     - paymentId
1050 
    """
1051 
    pass
1052 
 
1053 
  def getEBSSettlementSummaries(self, ):
1054 
    pass
1055 
 
1056 
  def markEBSSettlementUploaded(self, settlementId):
1057 
    """
1058 
    Parameters:
1059 
     - settlementId
1060 
    """
1061 
    pass
1062 
 
1063 
  def getEBSSettlementDate(self, settlementId):
1064 
    """
1065 
    Parameters:
1066 
     - settlementId
1067 
    """
1068 
    pass
1069 
 
4715 varun.gupt 1070 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1071 
    """
1072 
    Parameters:
1073 
     - settlementDateFrom
1074 
     - settlementDateTo
1075 
     - isRefund
1076 
    """
1077 
    pass
4600 varun.gupt 1078 
 
4715 varun.gupt 1079 
  def getReshippedOrderIds(self, orderIds):
1080 
    """
1081 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1082 
 
1083 
    Parameters:
1084 
     - orderIds
1085 
    """
1086 
    pass
1087 
 
4757 mandeep.dh 1088 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
1089 
    """
1090 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
1091 
    the quantities for which the PO is raised.
4715 varun.gupt 1092 
 
4757 mandeep.dh 1093 
    Parameters:
1094 
     - itemIdQuantityMap
1095 
     - purchaseOrderId
1096 
     - warehouseId
1097 
    """
1098 
    pass
1099 
 
4875 varun.gupt 1100 
  def getOrdersWhereVendorNotPaid(self, vendorId):
1101 
    """
1102 
    Parameters:
1103 
     - vendorId
1104 
    """
1105 
    pass
4757 mandeep.dh 1106 
 
5031 varun.gupt 1107 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1108 
    """
1109 
    Parameters:
1110 
     - startDate
1111 
     - endDate
1112 
    """
1113 
    pass
4875 varun.gupt 1114 
 
5067 varun.gupt 1115 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1116 
    """
1117 
    Parameters:
1118 
     - status
1119 
     - startDatetime
1120 
     - endDatetime
1121 
    """
1122 
    pass
5031 varun.gupt 1123 
 
5099 varun.gupt 1124 
  def updateOrderAsPaidToVendor(self, orderId):
1125 
    """
1126 
    Parameters:
1127 
     - orderId
1128 
    """
1129 
    pass
5067 varun.gupt 1130 
 
5099 varun.gupt 1131 
 
3376 rajveer 1132 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1133 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1134 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1135 
 
1136 
  def createTransaction(self, transaction):
1137 
    """
1138 
    Parameters:
1139 
     - transaction
1140 
    """
1141 
    self.send_createTransaction(transaction)
132 ashish 1142 
    return self.recv_createTransaction()
94 ashish 1143 
 
1144 
  def send_createTransaction(self, transaction):
1145 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1146 
    args = createTransaction_args()
1147 
    args.transaction = transaction
1148 
    args.write(self._oprot)
1149 
    self._oprot.writeMessageEnd()
1150 
    self._oprot.trans.flush()
1151 
 
1152 
  def recv_createTransaction(self, ):
1153 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1154 
    if mtype == TMessageType.EXCEPTION:
1155 
      x = TApplicationException()
1156 
      x.read(self._iprot)
1157 
      self._iprot.readMessageEnd()
1158 
      raise x
1159 
    result = createTransaction_result()
1160 
    result.read(self._iprot)
1161 
    self._iprot.readMessageEnd()
3431 rajveer 1162 
    if result.success is not None:
132 ashish 1163 
      return result.success
3431 rajveer 1164 
    if result.ex is not None:
94 ashish 1165 
      raise result.ex
132 ashish 1166 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1167 
 
1168 
  def getTransaction(self, id):
1169 
    """
1170 
    Parameters:
1171 
     - id
1172 
    """
1173 
    self.send_getTransaction(id)
1174 
    return self.recv_getTransaction()
1175 
 
1176 
  def send_getTransaction(self, id):
1177 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1178 
    args = getTransaction_args()
1179 
    args.id = id
1180 
    args.write(self._oprot)
1181 
    self._oprot.writeMessageEnd()
1182 
    self._oprot.trans.flush()
1183 
 
1184 
  def recv_getTransaction(self, ):
1185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1186 
    if mtype == TMessageType.EXCEPTION:
1187 
      x = TApplicationException()
1188 
      x.read(self._iprot)
1189 
      self._iprot.readMessageEnd()
1190 
      raise x
1191 
    result = getTransaction_result()
1192 
    result.read(self._iprot)
1193 
    self._iprot.readMessageEnd()
3431 rajveer 1194 
    if result.success is not None:
94 ashish 1195 
      return result.success
3431 rajveer 1196 
    if result.ex is not None:
94 ashish 1197 
      raise result.ex
1198 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1199 
 
1200 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1201 
    """
1202 
    Parameters:
1203 
     - customerId
1204 
     - from_date
1205 
     - to_date
1206 
     - status
1207 
    """
1208 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1209 
    return self.recv_getTransactionsForCustomer()
1210 
 
1211 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1212 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1213 
    args = getTransactionsForCustomer_args()
1214 
    args.customerId = customerId
1215 
    args.from_date = from_date
1216 
    args.to_date = to_date
1217 
    args.status = status
1218 
    args.write(self._oprot)
1219 
    self._oprot.writeMessageEnd()
1220 
    self._oprot.trans.flush()
1221 
 
1222 
  def recv_getTransactionsForCustomer(self, ):
1223 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1224 
    if mtype == TMessageType.EXCEPTION:
1225 
      x = TApplicationException()
1226 
      x.read(self._iprot)
1227 
      self._iprot.readMessageEnd()
1228 
      raise x
1229 
    result = getTransactionsForCustomer_result()
1230 
    result.read(self._iprot)
1231 
    self._iprot.readMessageEnd()
3431 rajveer 1232 
    if result.success is not None:
94 ashish 1233 
      return result.success
3431 rajveer 1234 
    if result.ex is not None:
94 ashish 1235 
      raise result.ex
1236 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1237 
 
132 ashish 1238 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1239 
    """
1240 
    Parameters:
1241 
     - shoppingCartId
1242 
    """
1243 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1244 
    return self.recv_getTransactionsForShoppingCartId()
1245 
 
1246 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1247 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1248 
    args = getTransactionsForShoppingCartId_args()
1249 
    args.shoppingCartId = shoppingCartId
1250 
    args.write(self._oprot)
1251 
    self._oprot.writeMessageEnd()
1252 
    self._oprot.trans.flush()
1253 
 
1254 
  def recv_getTransactionsForShoppingCartId(self, ):
1255 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1256 
    if mtype == TMessageType.EXCEPTION:
1257 
      x = TApplicationException()
1258 
      x.read(self._iprot)
1259 
      self._iprot.readMessageEnd()
1260 
      raise x
1261 
    result = getTransactionsForShoppingCartId_result()
1262 
    result.read(self._iprot)
1263 
    self._iprot.readMessageEnd()
3431 rajveer 1264 
    if result.success is not None:
132 ashish 1265 
      return result.success
3431 rajveer 1266 
    if result.ex is not None:
132 ashish 1267 
      raise result.ex
1268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1269 
 
94 ashish 1270 
  def getTransactionStatus(self, transactionId):
1271 
    """
1272 
    Parameters:
1273 
     - transactionId
1274 
    """
1275 
    self.send_getTransactionStatus(transactionId)
1276 
    return self.recv_getTransactionStatus()
1277 
 
1278 
  def send_getTransactionStatus(self, transactionId):
1279 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1280 
    args = getTransactionStatus_args()
1281 
    args.transactionId = transactionId
1282 
    args.write(self._oprot)
1283 
    self._oprot.writeMessageEnd()
1284 
    self._oprot.trans.flush()
1285 
 
1286 
  def recv_getTransactionStatus(self, ):
1287 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1288 
    if mtype == TMessageType.EXCEPTION:
1289 
      x = TApplicationException()
1290 
      x.read(self._iprot)
1291 
      self._iprot.readMessageEnd()
1292 
      raise x
1293 
    result = getTransactionStatus_result()
1294 
    result.read(self._iprot)
1295 
    self._iprot.readMessageEnd()
3431 rajveer 1296 
    if result.success is not None:
94 ashish 1297 
      return result.success
3431 rajveer 1298 
    if result.ex is not None:
94 ashish 1299 
      raise result.ex
1300 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1301 
 
1302 
  def changeTransactionStatus(self, transactionId, status, description):
1303 
    """
1304 
    Parameters:
1305 
     - transactionId
1306 
     - status
1307 
     - description
1308 
    """
1309 
    self.send_changeTransactionStatus(transactionId, status, description)
1310 
    return self.recv_changeTransactionStatus()
1311 
 
1312 
  def send_changeTransactionStatus(self, transactionId, status, description):
1313 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1314 
    args = changeTransactionStatus_args()
1315 
    args.transactionId = transactionId
1316 
    args.status = status
1317 
    args.description = description
1318 
    args.write(self._oprot)
1319 
    self._oprot.writeMessageEnd()
1320 
    self._oprot.trans.flush()
1321 
 
1322 
  def recv_changeTransactionStatus(self, ):
1323 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1324 
    if mtype == TMessageType.EXCEPTION:
1325 
      x = TApplicationException()
1326 
      x.read(self._iprot)
1327 
      self._iprot.readMessageEnd()
1328 
      raise x
1329 
    result = changeTransactionStatus_result()
1330 
    result.read(self._iprot)
1331 
    self._iprot.readMessageEnd()
3431 rajveer 1332 
    if result.success is not None:
94 ashish 1333 
      return result.success
3431 rajveer 1334 
    if result.ex is not None:
94 ashish 1335 
      raise result.ex
1336 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1337 
 
1398 varun.gupt 1338 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1339 
    """
1340 
    Parameters:
1341 
     - transactionId
1342 
    """
1398 varun.gupt 1343 
    self.send_enqueueTransactionInfoEmail(transactionId)
1344 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1345 
 
1398 varun.gupt 1346 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1347 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1348 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1349 
    args.transactionId = transactionId
1350 
    args.write(self._oprot)
1351 
    self._oprot.writeMessageEnd()
1352 
    self._oprot.trans.flush()
1353 
 
1398 varun.gupt 1354 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1356 
    if mtype == TMessageType.EXCEPTION:
1357 
      x = TApplicationException()
1358 
      x.read(self._iprot)
1359 
      self._iprot.readMessageEnd()
1360 
      raise x
1398 varun.gupt 1361 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1362 
    result.read(self._iprot)
1363 
    self._iprot.readMessageEnd()
3431 rajveer 1364 
    if result.success is not None:
1382 varun.gupt 1365 
      return result.success
3431 rajveer 1366 
    if result.ex is not None:
1382 varun.gupt 1367 
      raise result.ex
1398 varun.gupt 1368 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1369 
 
4801 anupam.sin 1370 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1371 
    """
1372 
    Parameters:
4801 anupam.sin 1373 
     - statuses
483 rajveer 1374 
     - from_date
1375 
     - to_date
1376 
     - warehouse_id
94 ashish 1377 
    """
4801 anupam.sin 1378 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1379 
    return self.recv_getAllOrders()
94 ashish 1380 
 
4801 anupam.sin 1381 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1382 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1383 
    args = getAllOrders_args()
4801 anupam.sin 1384 
    args.statuses = statuses
483 rajveer 1385 
    args.from_date = from_date
1386 
    args.to_date = to_date
1387 
    args.warehouse_id = warehouse_id
94 ashish 1388 
    args.write(self._oprot)
1389 
    self._oprot.writeMessageEnd()
1390 
    self._oprot.trans.flush()
1391 
 
483 rajveer 1392 
  def recv_getAllOrders(self, ):
94 ashish 1393 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1394 
    if mtype == TMessageType.EXCEPTION:
1395 
      x = TApplicationException()
1396 
      x.read(self._iprot)
1397 
      self._iprot.readMessageEnd()
1398 
      raise x
483 rajveer 1399 
    result = getAllOrders_result()
94 ashish 1400 
    result.read(self._iprot)
1401 
    self._iprot.readMessageEnd()
3431 rajveer 1402 
    if result.success is not None:
94 ashish 1403 
      return result.success
3431 rajveer 1404 
    if result.ex is not None:
94 ashish 1405 
      raise result.ex
483 rajveer 1406 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1407 
 
4133 chandransh 1408 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1409 
    """
1410 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1411 
    Pass the status as null and the limit as 0 to ignore them.
1412 
 
1413 
    Parameters:
1414 
     - statuses
1415 
     - offset
1416 
     - limit
1417 
     - warehouse_id
1418 
    """
1419 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1420 
    return self.recv_getOrdersInBatch()
1421 
 
1422 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1423 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1424 
    args = getOrdersInBatch_args()
1425 
    args.statuses = statuses
1426 
    args.offset = offset
1427 
    args.limit = limit
1428 
    args.warehouse_id = warehouse_id
1429 
    args.write(self._oprot)
1430 
    self._oprot.writeMessageEnd()
1431 
    self._oprot.trans.flush()
1432 
 
1433 
  def recv_getOrdersInBatch(self, ):
1434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1435 
    if mtype == TMessageType.EXCEPTION:
1436 
      x = TApplicationException()
1437 
      x.read(self._iprot)
1438 
      self._iprot.readMessageEnd()
1439 
      raise x
1440 
    result = getOrdersInBatch_result()
1441 
    result.read(self._iprot)
1442 
    self._iprot.readMessageEnd()
1443 
    if result.success is not None:
1444 
      return result.success
1445 
    if result.ex is not None:
1446 
      raise result.ex
1447 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1448 
 
1449 
  def getOrderCount(self, statuses, warehouseId):
1450 
    """
1451 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1452 
 
1453 
    Parameters:
1454 
     - statuses
1455 
     - warehouseId
1456 
    """
1457 
    self.send_getOrderCount(statuses, warehouseId)
1458 
    return self.recv_getOrderCount()
1459 
 
1460 
  def send_getOrderCount(self, statuses, warehouseId):
1461 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1462 
    args = getOrderCount_args()
1463 
    args.statuses = statuses
1464 
    args.warehouseId = warehouseId
1465 
    args.write(self._oprot)
1466 
    self._oprot.writeMessageEnd()
1467 
    self._oprot.trans.flush()
1468 
 
1469 
  def recv_getOrderCount(self, ):
1470 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1471 
    if mtype == TMessageType.EXCEPTION:
1472 
      x = TApplicationException()
1473 
      x.read(self._iprot)
1474 
      self._iprot.readMessageEnd()
1475 
      raise x
1476 
    result = getOrderCount_result()
1477 
    result.read(self._iprot)
1478 
    self._iprot.readMessageEnd()
1479 
    if result.success is not None:
1480 
      return result.success
1481 
    if result.ex is not None:
1482 
      raise result.ex
1483 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1484 
 
999 varun.gupt 1485 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1486 
    """
1132 chandransh 1487 
    Returns orders within a range of their billing dates
3431 rajveer 1488 
 
999 varun.gupt 1489 
    Parameters:
1490 
     - status
1491 
     - start_billing_date
1492 
     - end_billing_date
1493 
     - warehouse_id
1494 
    """
1495 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1496 
    return self.recv_getOrdersByBillingDate()
1497 
 
1498 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1499 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1500 
    args = getOrdersByBillingDate_args()
1501 
    args.status = status
1502 
    args.start_billing_date = start_billing_date
1503 
    args.end_billing_date = end_billing_date
1504 
    args.warehouse_id = warehouse_id
1505 
    args.write(self._oprot)
1506 
    self._oprot.writeMessageEnd()
1507 
    self._oprot.trans.flush()
1508 
 
1509 
  def recv_getOrdersByBillingDate(self, ):
1510 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1511 
    if mtype == TMessageType.EXCEPTION:
1512 
      x = TApplicationException()
1513 
      x.read(self._iprot)
1514 
      self._iprot.readMessageEnd()
1515 
      raise x
1516 
    result = getOrdersByBillingDate_result()
1517 
    result.read(self._iprot)
1518 
    self._iprot.readMessageEnd()
3431 rajveer 1519 
    if result.success is not None:
999 varun.gupt 1520 
      return result.success
3431 rajveer 1521 
    if result.ex is not None:
999 varun.gupt 1522 
      raise result.ex
1523 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1524 
 
3451 chandransh 1525 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1526 
    """
1527 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1528 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1529 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1530 
 
3427 chandransh 1531 
    Parameters:
1532 
     - fromShippingDate
1533 
     - toShippingDate
1534 
     - providerId
1535 
     - warehouseId
3451 chandransh 1536 
     - cod
3427 chandransh 1537 
    """
3451 chandransh 1538 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1539 
    return self.recv_getOrdersByShippingDate()
1540 
 
3451 chandransh 1541 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1542 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1543 
    args = getOrdersByShippingDate_args()
1544 
    args.fromShippingDate = fromShippingDate
1545 
    args.toShippingDate = toShippingDate
1546 
    args.providerId = providerId
1547 
    args.warehouseId = warehouseId
3451 chandransh 1548 
    args.cod = cod
3427 chandransh 1549 
    args.write(self._oprot)
1550 
    self._oprot.writeMessageEnd()
1551 
    self._oprot.trans.flush()
1552 
 
1553 
  def recv_getOrdersByShippingDate(self, ):
1554 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1555 
    if mtype == TMessageType.EXCEPTION:
1556 
      x = TApplicationException()
1557 
      x.read(self._iprot)
1558 
      self._iprot.readMessageEnd()
1559 
      raise x
1560 
    result = getOrdersByShippingDate_result()
1561 
    result.read(self._iprot)
1562 
    self._iprot.readMessageEnd()
3431 rajveer 1563 
    if result.success is not None:
3427 chandransh 1564 
      return result.success
3431 rajveer 1565 
    if result.ex is not None:
3427 chandransh 1566 
      raise result.ex
1567 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1568 
 
1382 varun.gupt 1569 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1570 
    """
1571 
    Returns order ids for orders which can be returned
3431 rajveer 1572 
 
1382 varun.gupt 1573 
    Parameters:
1574 
     - customer_id
1575 
     - limit
1576 
    """
1577 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1578 
    return self.recv_getReturnableOrdersForCustomer()
1579 
 
1580 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1581 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1582 
    args = getReturnableOrdersForCustomer_args()
1583 
    args.customer_id = customer_id
1584 
    args.limit = limit
1585 
    args.write(self._oprot)
1586 
    self._oprot.writeMessageEnd()
1587 
    self._oprot.trans.flush()
1588 
 
1589 
  def recv_getReturnableOrdersForCustomer(self, ):
1590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1591 
    if mtype == TMessageType.EXCEPTION:
1592 
      x = TApplicationException()
1593 
      x.read(self._iprot)
1594 
      self._iprot.readMessageEnd()
1595 
      raise x
1596 
    result = getReturnableOrdersForCustomer_result()
1597 
    result.read(self._iprot)
1598 
    self._iprot.readMessageEnd()
3431 rajveer 1599 
    if result.success is not None:
1382 varun.gupt 1600 
      return result.success
3431 rajveer 1601 
    if result.ex is not None:
1382 varun.gupt 1602 
      raise result.ex
1603 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1604 
 
1605 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1606 
    """
1607 
    Returns order ids for orders which can be cancelled
3431 rajveer 1608 
 
1382 varun.gupt 1609 
    Parameters:
1610 
     - customer_id
1611 
     - limit
1612 
    """
1613 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1614 
    return self.recv_getCancellableOrdersForCustomer()
1615 
 
1616 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1617 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1618 
    args = getCancellableOrdersForCustomer_args()
1619 
    args.customer_id = customer_id
1620 
    args.limit = limit
1621 
    args.write(self._oprot)
1622 
    self._oprot.writeMessageEnd()
1623 
    self._oprot.trans.flush()
1624 
 
1625 
  def recv_getCancellableOrdersForCustomer(self, ):
1626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1627 
    if mtype == TMessageType.EXCEPTION:
1628 
      x = TApplicationException()
1629 
      x.read(self._iprot)
1630 
      self._iprot.readMessageEnd()
1631 
      raise x
1632 
    result = getCancellableOrdersForCustomer_result()
1633 
    result.read(self._iprot)
1634 
    self._iprot.readMessageEnd()
3431 rajveer 1635 
    if result.success is not None:
1382 varun.gupt 1636 
      return result.success
3431 rajveer 1637 
    if result.ex is not None:
1382 varun.gupt 1638 
      raise result.ex
1639 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1640 
 
483 rajveer 1641 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1642 
    """
1643 
    Parameters:
483 rajveer 1644 
     - orderId
1645 
     - status
1646 
     - description
94 ashish 1647 
    """
483 rajveer 1648 
    self.send_changeOrderStatus(orderId, status, description)
1649 
    return self.recv_changeOrderStatus()
94 ashish 1650 
 
483 rajveer 1651 
  def send_changeOrderStatus(self, orderId, status, description):
1652 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1653 
    args = changeOrderStatus_args()
1654 
    args.orderId = orderId
1655 
    args.status = status
1656 
    args.description = description
94 ashish 1657 
    args.write(self._oprot)
1658 
    self._oprot.writeMessageEnd()
1659 
    self._oprot.trans.flush()
1660 
 
483 rajveer 1661 
  def recv_changeOrderStatus(self, ):
94 ashish 1662 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1663 
    if mtype == TMessageType.EXCEPTION:
1664 
      x = TApplicationException()
1665 
      x.read(self._iprot)
1666 
      self._iprot.readMessageEnd()
1667 
      raise x
483 rajveer 1668 
    result = changeOrderStatus_result()
94 ashish 1669 
    result.read(self._iprot)
1670 
    self._iprot.readMessageEnd()
3431 rajveer 1671 
    if result.success is not None:
94 ashish 1672 
      return result.success
3431 rajveer 1673 
    if result.ex is not None:
94 ashish 1674 
      raise result.ex
483 rajveer 1675 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1676 
 
1528 ankur.sing 1677 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1678 
    """
1528 ankur.sing 1679 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1680 
    only user who owns the transaction can view its order details.
3431 rajveer 1681 
 
94 ashish 1682 
    Parameters:
1683 
     - transactionId
1528 ankur.sing 1684 
     - customerId
94 ashish 1685 
    """
1528 ankur.sing 1686 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1687 
    return self.recv_getOrdersForTransaction()
94 ashish 1688 
 
1528 ankur.sing 1689 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1690 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1691 
    args = getOrdersForTransaction_args()
94 ashish 1692 
    args.transactionId = transactionId
1528 ankur.sing 1693 
    args.customerId = customerId
94 ashish 1694 
    args.write(self._oprot)
1695 
    self._oprot.writeMessageEnd()
1696 
    self._oprot.trans.flush()
1697 
 
483 rajveer 1698 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1699 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1700 
    if mtype == TMessageType.EXCEPTION:
1701 
      x = TApplicationException()
1702 
      x.read(self._iprot)
1703 
      self._iprot.readMessageEnd()
1704 
      raise x
483 rajveer 1705 
    result = getOrdersForTransaction_result()
94 ashish 1706 
    result.read(self._iprot)
1707 
    self._iprot.readMessageEnd()
3431 rajveer 1708 
    if result.success is not None:
94 ashish 1709 
      return result.success
3431 rajveer 1710 
    if result.ex is not None:
94 ashish 1711 
      raise result.ex
483 rajveer 1712 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1713 
 
3014 chandransh 1714 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1715 
    """
3014 chandransh 1716 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1717 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1718 
 
94 ashish 1719 
    Parameters:
483 rajveer 1720 
     - customerId
1721 
     - from_date
1722 
     - to_date
3014 chandransh 1723 
     - statuses
94 ashish 1724 
    """
3014 chandransh 1725 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1726 
    return self.recv_getOrdersForCustomer()
94 ashish 1727 
 
3014 chandransh 1728 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1729 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1730 
    args = getOrdersForCustomer_args()
1731 
    args.customerId = customerId
1732 
    args.from_date = from_date
1733 
    args.to_date = to_date
3014 chandransh 1734 
    args.statuses = statuses
94 ashish 1735 
    args.write(self._oprot)
1736 
    self._oprot.writeMessageEnd()
1737 
    self._oprot.trans.flush()
1738 
 
483 rajveer 1739 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1740 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1741 
    if mtype == TMessageType.EXCEPTION:
1742 
      x = TApplicationException()
1743 
      x.read(self._iprot)
1744 
      self._iprot.readMessageEnd()
1745 
      raise x
483 rajveer 1746 
    result = getOrdersForCustomer_result()
94 ashish 1747 
    result.read(self._iprot)
1748 
    self._iprot.readMessageEnd()
3431 rajveer 1749 
    if result.success is not None:
94 ashish 1750 
      return result.success
3431 rajveer 1751 
    if result.ex is not None:
94 ashish 1752 
      raise result.ex
483 rajveer 1753 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1754 
 
483 rajveer 1755 
  def createOrder(self, order):
94 ashish 1756 
    """
1757 
    Parameters:
483 rajveer 1758 
     - order
94 ashish 1759 
    """
483 rajveer 1760 
    self.send_createOrder(order)
1761 
    return self.recv_createOrder()
94 ashish 1762 
 
483 rajveer 1763 
  def send_createOrder(self, order):
1764 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1765 
    args = createOrder_args()
1766 
    args.order = order
94 ashish 1767 
    args.write(self._oprot)
1768 
    self._oprot.writeMessageEnd()
1769 
    self._oprot.trans.flush()
1770 
 
483 rajveer 1771 
  def recv_createOrder(self, ):
94 ashish 1772 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1773 
    if mtype == TMessageType.EXCEPTION:
1774 
      x = TApplicationException()
1775 
      x.read(self._iprot)
1776 
      self._iprot.readMessageEnd()
1777 
      raise x
483 rajveer 1778 
    result = createOrder_result()
94 ashish 1779 
    result.read(self._iprot)
1780 
    self._iprot.readMessageEnd()
3431 rajveer 1781 
    if result.success is not None:
94 ashish 1782 
      return result.success
3431 rajveer 1783 
    if result.ex is not None:
94 ashish 1784 
      raise result.ex
483 rajveer 1785 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1786 
 
483 rajveer 1787 
  def getOrder(self, id):
94 ashish 1788 
    """
1789 
    Parameters:
483 rajveer 1790 
     - id
94 ashish 1791 
    """
483 rajveer 1792 
    self.send_getOrder(id)
1793 
    return self.recv_getOrder()
94 ashish 1794 
 
483 rajveer 1795 
  def send_getOrder(self, id):
1796 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1797 
    args = getOrder_args()
1798 
    args.id = id
94 ashish 1799 
    args.write(self._oprot)
1800 
    self._oprot.writeMessageEnd()
1801 
    self._oprot.trans.flush()
1802 
 
483 rajveer 1803 
  def recv_getOrder(self, ):
94 ashish 1804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1805 
    if mtype == TMessageType.EXCEPTION:
1806 
      x = TApplicationException()
1807 
      x.read(self._iprot)
1808 
      self._iprot.readMessageEnd()
1809 
      raise x
483 rajveer 1810 
    result = getOrder_result()
94 ashish 1811 
    result.read(self._iprot)
1812 
    self._iprot.readMessageEnd()
3431 rajveer 1813 
    if result.success is not None:
94 ashish 1814 
      return result.success
3431 rajveer 1815 
    if result.ex is not None:
94 ashish 1816 
      raise result.ex
483 rajveer 1817 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1818 
 
483 rajveer 1819 
  def getLineItemsForOrder(self, orderId):
94 ashish 1820 
    """
1821 
    Parameters:
483 rajveer 1822 
     - orderId
94 ashish 1823 
    """
483 rajveer 1824 
    self.send_getLineItemsForOrder(orderId)
1825 
    return self.recv_getLineItemsForOrder()
94 ashish 1826 
 
483 rajveer 1827 
  def send_getLineItemsForOrder(self, orderId):
1828 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1829 
    args = getLineItemsForOrder_args()
1830 
    args.orderId = orderId
94 ashish 1831 
    args.write(self._oprot)
1832 
    self._oprot.writeMessageEnd()
1833 
    self._oprot.trans.flush()
1834 
 
483 rajveer 1835 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1836 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1837 
    if mtype == TMessageType.EXCEPTION:
1838 
      x = TApplicationException()
1839 
      x.read(self._iprot)
1840 
      self._iprot.readMessageEnd()
1841 
      raise x
483 rajveer 1842 
    result = getLineItemsForOrder_result()
94 ashish 1843 
    result.read(self._iprot)
1844 
    self._iprot.readMessageEnd()
3431 rajveer 1845 
    if result.success is not None:
94 ashish 1846 
      return result.success
3431 rajveer 1847 
    if result.ex is not None:
94 ashish 1848 
      raise result.ex
483 rajveer 1849 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1850 
 
4999 phani.kuma 1851 
  def getOrderList(self, order_ids):
1852 
    """
1853 
    Parameters:
1854 
     - order_ids
1855 
    """
1856 
    self.send_getOrderList(order_ids)
1857 
    return self.recv_getOrderList()
1858 
 
1859 
  def send_getOrderList(self, order_ids):
1860 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
1861 
    args = getOrderList_args()
1862 
    args.order_ids = order_ids
1863 
    args.write(self._oprot)
1864 
    self._oprot.writeMessageEnd()
1865 
    self._oprot.trans.flush()
1866 
 
1867 
  def recv_getOrderList(self, ):
1868 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1869 
    if mtype == TMessageType.EXCEPTION:
1870 
      x = TApplicationException()
1871 
      x.read(self._iprot)
1872 
      self._iprot.readMessageEnd()
1873 
      raise x
1874 
    result = getOrderList_result()
1875 
    result.read(self._iprot)
1876 
    self._iprot.readMessageEnd()
1877 
    if result.success is not None:
1878 
      return result.success
1879 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
1880 
 
1528 ankur.sing 1881 
  def getOrderForCustomer(self, orderId, customerId):
1882 
    """
1883 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1884 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1885 
 
1528 ankur.sing 1886 
    Parameters:
1887 
     - orderId
1888 
     - customerId
1889 
    """
1890 
    self.send_getOrderForCustomer(orderId, customerId)
1891 
    return self.recv_getOrderForCustomer()
1892 
 
1893 
  def send_getOrderForCustomer(self, orderId, customerId):
1894 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1895 
    args = getOrderForCustomer_args()
1896 
    args.orderId = orderId
1897 
    args.customerId = customerId
1898 
    args.write(self._oprot)
1899 
    self._oprot.writeMessageEnd()
1900 
    self._oprot.trans.flush()
1901 
 
1902 
  def recv_getOrderForCustomer(self, ):
1903 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1904 
    if mtype == TMessageType.EXCEPTION:
1905 
      x = TApplicationException()
1906 
      x.read(self._iprot)
1907 
      self._iprot.readMessageEnd()
1908 
      raise x
1909 
    result = getOrderForCustomer_result()
1910 
    result.read(self._iprot)
1911 
    self._iprot.readMessageEnd()
3431 rajveer 1912 
    if result.success is not None:
1528 ankur.sing 1913 
      return result.success
3431 rajveer 1914 
    if result.ex is not None:
1528 ankur.sing 1915 
      raise result.ex
1916 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1917 
 
4444 rajveer 1918 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1919 
    """
1920 
    Parameters:
4394 rajveer 1921 
     - type
4444 rajveer 1922 
     - warehouseId
4394 rajveer 1923 
     - status
1924 
     - timestamp
3064 chandransh 1925 
    """
4444 rajveer 1926 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1927 
    return self.recv_getAlerts()
1928 
 
4444 rajveer 1929 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1930 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1931 
    args = getAlerts_args()
4394 rajveer 1932 
    args.type = type
4444 rajveer 1933 
    args.warehouseId = warehouseId
4394 rajveer 1934 
    args.status = status
1935 
    args.timestamp = timestamp
3064 chandransh 1936 
    args.write(self._oprot)
1937 
    self._oprot.writeMessageEnd()
1938 
    self._oprot.trans.flush()
1939 
 
1940 
  def recv_getAlerts(self, ):
1941 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1942 
    if mtype == TMessageType.EXCEPTION:
1943 
      x = TApplicationException()
1944 
      x.read(self._iprot)
1945 
      self._iprot.readMessageEnd()
1946 
      raise x
1947 
    result = getAlerts_result()
1948 
    result.read(self._iprot)
1949 
    self._iprot.readMessageEnd()
3431 rajveer 1950 
    if result.success is not None:
3064 chandransh 1951 
      return result.success
1952 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1953 
 
4444 rajveer 1954 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1955 
    """
1956 
    Parameters:
1957 
     - type
4444 rajveer 1958 
     - warehouseId
4394 rajveer 1959 
     - description
3064 chandransh 1960 
    """
4444 rajveer 1961 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1962 
    self.recv_addAlert()
3064 chandransh 1963 
 
4444 rajveer 1964 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1965 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1966 
    args = addAlert_args()
3064 chandransh 1967 
    args.type = type
4444 rajveer 1968 
    args.warehouseId = warehouseId
4394 rajveer 1969 
    args.description = description
3064 chandransh 1970 
    args.write(self._oprot)
1971 
    self._oprot.writeMessageEnd()
1972 
    self._oprot.trans.flush()
1973 
 
4394 rajveer 1974 
  def recv_addAlert(self, ):
3064 chandransh 1975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1976 
    if mtype == TMessageType.EXCEPTION:
1977 
      x = TApplicationException()
1978 
      x.read(self._iprot)
1979 
      self._iprot.readMessageEnd()
1980 
      raise x
4394 rajveer 1981 
    result = addAlert_result()
3064 chandransh 1982 
    result.read(self._iprot)
1983 
    self._iprot.readMessageEnd()
1984 
    return
1985 
 
4444 rajveer 1986 
  def markAlertsAsSeen(self, warehouseId):
1987 
    """
1988 
    Parameters:
1989 
     - warehouseId
1990 
    """
1991 
    self.send_markAlertsAsSeen(warehouseId)
1992 
    self.recv_markAlertsAsSeen()
1993 
 
1994 
  def send_markAlertsAsSeen(self, warehouseId):
1995 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1996 
    args = markAlertsAsSeen_args()
1997 
    args.warehouseId = warehouseId
1998 
    args.write(self._oprot)
1999 
    self._oprot.writeMessageEnd()
2000 
    self._oprot.trans.flush()
2001 
 
2002 
  def recv_markAlertsAsSeen(self, ):
2003 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2004 
    if mtype == TMessageType.EXCEPTION:
2005 
      x = TApplicationException()
2006 
      x.read(self._iprot)
2007 
      self._iprot.readMessageEnd()
2008 
      raise x
2009 
    result = markAlertsAsSeen_result()
2010 
    result.read(self._iprot)
2011 
    self._iprot.readMessageEnd()
2012 
    return
2013 
 
3064 chandransh 2014 
  def getValidOrderCount(self, ):
2015 
    """
2016 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2017 
    """
2018 
    self.send_getValidOrderCount()
2019 
    return self.recv_getValidOrderCount()
2020 
 
2021 
  def send_getValidOrderCount(self, ):
2022 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2023 
    args = getValidOrderCount_args()
2024 
    args.write(self._oprot)
2025 
    self._oprot.writeMessageEnd()
2026 
    self._oprot.trans.flush()
2027 
 
2028 
  def recv_getValidOrderCount(self, ):
2029 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2030 
    if mtype == TMessageType.EXCEPTION:
2031 
      x = TApplicationException()
2032 
      x.read(self._iprot)
2033 
      self._iprot.readMessageEnd()
2034 
      raise x
2035 
    result = getValidOrderCount_result()
2036 
    result.read(self._iprot)
2037 
    self._iprot.readMessageEnd()
3431 rajveer 2038 
    if result.success is not None:
3064 chandransh 2039 
      return result.success
2040 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2041 
 
2042 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2043 
    """
2044 
    Returns the number of distinct customers who have done successful transactions
2045 
    """
2046 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2047 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2048 
 
2049 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2050 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2051 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2052 
    args.write(self._oprot)
2053 
    self._oprot.writeMessageEnd()
2054 
    self._oprot.trans.flush()
2055 
 
2056 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2058 
    if mtype == TMessageType.EXCEPTION:
2059 
      x = TApplicationException()
2060 
      x.read(self._iprot)
2061 
      self._iprot.readMessageEnd()
2062 
      raise x
2063 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2064 
    result.read(self._iprot)
2065 
    self._iprot.readMessageEnd()
3431 rajveer 2066 
    if result.success is not None:
3064 chandransh 2067 
      return result.success
2068 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2069 
 
2070 
  def getValidOrdersAmountRange(self, ):
2071 
    """
2072 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2073 
    List contains two values, first minimum amount and second maximum amount.
2074 
    """
2075 
    self.send_getValidOrdersAmountRange()
2076 
    return self.recv_getValidOrdersAmountRange()
2077 
 
2078 
  def send_getValidOrdersAmountRange(self, ):
2079 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2080 
    args = getValidOrdersAmountRange_args()
2081 
    args.write(self._oprot)
2082 
    self._oprot.writeMessageEnd()
2083 
    self._oprot.trans.flush()
2084 
 
2085 
  def recv_getValidOrdersAmountRange(self, ):
2086 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2087 
    if mtype == TMessageType.EXCEPTION:
2088 
      x = TApplicationException()
2089 
      x.read(self._iprot)
2090 
      self._iprot.readMessageEnd()
2091 
      raise x
2092 
    result = getValidOrdersAmountRange_result()
2093 
    result.read(self._iprot)
2094 
    self._iprot.readMessageEnd()
3431 rajveer 2095 
    if result.success is not None:
3064 chandransh 2096 
      return result.success
2097 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2098 
 
2099 
  def getValidOrders(self, limit):
2100 
    """
2101 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2102 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2103 
 
3064 chandransh 2104 
    Parameters:
2105 
     - limit
2106 
    """
2107 
    self.send_getValidOrders(limit)
2108 
    return self.recv_getValidOrders()
2109 
 
2110 
  def send_getValidOrders(self, limit):
2111 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2112 
    args = getValidOrders_args()
2113 
    args.limit = limit
2114 
    args.write(self._oprot)
2115 
    self._oprot.writeMessageEnd()
2116 
    self._oprot.trans.flush()
2117 
 
2118 
  def recv_getValidOrders(self, ):
2119 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2120 
    if mtype == TMessageType.EXCEPTION:
2121 
      x = TApplicationException()
2122 
      x.read(self._iprot)
2123 
      self._iprot.readMessageEnd()
2124 
      raise x
2125 
    result = getValidOrders_result()
2126 
    result.read(self._iprot)
2127 
    self._iprot.readMessageEnd()
3431 rajveer 2128 
    if result.success is not None:
3064 chandransh 2129 
      return result.success
2130 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2131 
 
1220 chandransh 2132 
  def batchOrders(self, warehouseId):
2133 
    """
2134 
    Create a batch of all the pending orders for the given warehouse.
2135 
    The returned list is orderd by created_timestamp.
2136 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2137 
 
1220 chandransh 2138 
    Parameters:
2139 
     - warehouseId
2140 
    """
2141 
    self.send_batchOrders(warehouseId)
2142 
    return self.recv_batchOrders()
2143 
 
2144 
  def send_batchOrders(self, warehouseId):
2145 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2146 
    args = batchOrders_args()
2147 
    args.warehouseId = warehouseId
2148 
    args.write(self._oprot)
2149 
    self._oprot.writeMessageEnd()
2150 
    self._oprot.trans.flush()
2151 
 
2152 
  def recv_batchOrders(self, ):
2153 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2154 
    if mtype == TMessageType.EXCEPTION:
2155 
      x = TApplicationException()
2156 
      x.read(self._iprot)
2157 
      self._iprot.readMessageEnd()
2158 
      raise x
2159 
    result = batchOrders_result()
2160 
    result.read(self._iprot)
2161 
    self._iprot.readMessageEnd()
3431 rajveer 2162 
    if result.success is not None:
1220 chandransh 2163 
      return result.success
3431 rajveer 2164 
    if result.ex is not None:
1220 chandransh 2165 
      raise result.ex
2166 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2167 
 
1208 chandransh 2168 
  def markOrderAsOutOfStock(self, orderId):
2169 
    """
2170 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2171 
 
1208 chandransh 2172 
    Parameters:
2173 
     - orderId
2174 
    """
2175 
    self.send_markOrderAsOutOfStock(orderId)
2176 
    return self.recv_markOrderAsOutOfStock()
2177 
 
2178 
  def send_markOrderAsOutOfStock(self, orderId):
2179 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2180 
    args = markOrderAsOutOfStock_args()
2181 
    args.orderId = orderId
2182 
    args.write(self._oprot)
2183 
    self._oprot.writeMessageEnd()
2184 
    self._oprot.trans.flush()
2185 
 
2186 
  def recv_markOrderAsOutOfStock(self, ):
2187 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2188 
    if mtype == TMessageType.EXCEPTION:
2189 
      x = TApplicationException()
2190 
      x.read(self._iprot)
2191 
      self._iprot.readMessageEnd()
2192 
      raise x
2193 
    result = markOrderAsOutOfStock_result()
2194 
    result.read(self._iprot)
2195 
    self._iprot.readMessageEnd()
3431 rajveer 2196 
    if result.success is not None:
1208 chandransh 2197 
      return result.success
3431 rajveer 2198 
    if result.ex is not None:
1208 chandransh 2199 
      raise result.ex
2200 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2201 
 
3064 chandransh 2202 
  def verifyOrder(self, orderId):
759 chandransh 2203 
    """
3064 chandransh 2204 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2205 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2206 
    used for all other orders as well.
2207 
    Throws an exception if no such order exists.
3431 rajveer 2208 
 
759 chandransh 2209 
    Parameters:
3064 chandransh 2210 
     - orderId
759 chandransh 2211 
    """
3064 chandransh 2212 
    self.send_verifyOrder(orderId)
2213 
    return self.recv_verifyOrder()
759 chandransh 2214 
 
3064 chandransh 2215 
  def send_verifyOrder(self, orderId):
2216 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2217 
    args = verifyOrder_args()
2218 
    args.orderId = orderId
759 chandransh 2219 
    args.write(self._oprot)
2220 
    self._oprot.writeMessageEnd()
2221 
    self._oprot.trans.flush()
2222 
 
3064 chandransh 2223 
  def recv_verifyOrder(self, ):
759 chandransh 2224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2225 
    if mtype == TMessageType.EXCEPTION:
2226 
      x = TApplicationException()
2227 
      x.read(self._iprot)
2228 
      self._iprot.readMessageEnd()
2229 
      raise x
3064 chandransh 2230 
    result = verifyOrder_result()
759 chandransh 2231 
    result.read(self._iprot)
2232 
    self._iprot.readMessageEnd()
3431 rajveer 2233 
    if result.success is not None:
759 chandransh 2234 
      return result.success
3431 rajveer 2235 
    if result.ex is not None:
759 chandransh 2236 
      raise result.ex
3064 chandransh 2237 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2238 
 
3064 chandransh 2239 
  def acceptOrder(self, orderId):
1113 chandransh 2240 
    """
3064 chandransh 2241 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2242 
    given order is not a COD order, it also captures the payment if the same has
2243 
    not been captured.
2244 
    Throws an exception if no such order exists.
3431 rajveer 2245 
 
1113 chandransh 2246 
    Parameters:
3064 chandransh 2247 
     - orderId
1113 chandransh 2248 
    """
3064 chandransh 2249 
    self.send_acceptOrder(orderId)
2250 
    return self.recv_acceptOrder()
1113 chandransh 2251 
 
3064 chandransh 2252 
  def send_acceptOrder(self, orderId):
2253 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2254 
    args = acceptOrder_args()
2255 
    args.orderId = orderId
1113 chandransh 2256 
    args.write(self._oprot)
2257 
    self._oprot.writeMessageEnd()
2258 
    self._oprot.trans.flush()
2259 
 
3064 chandransh 2260 
  def recv_acceptOrder(self, ):
1113 chandransh 2261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2262 
    if mtype == TMessageType.EXCEPTION:
2263 
      x = TApplicationException()
2264 
      x.read(self._iprot)
2265 
      self._iprot.readMessageEnd()
2266 
      raise x
3064 chandransh 2267 
    result = acceptOrder_result()
1113 chandransh 2268 
    result.read(self._iprot)
2269 
    self._iprot.readMessageEnd()
3431 rajveer 2270 
    if result.success is not None:
1113 chandransh 2271 
      return result.success
3431 rajveer 2272 
    if result.ex is not None:
1113 chandransh 2273 
      raise result.ex
3064 chandransh 2274 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2275 
 
5110 mandeep.dh 2276 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2277 
    """
3064 chandransh 2278 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2279 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2280 
    the IMEI no. if a -1 is supplied.
2281 
    Also, it generates an invoice number for the order, marks the order as
2282 
    BILLED and sets the billing timestamp.
2283 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2284 
 
1135 chandransh 2285 
    Parameters:
3064 chandransh 2286 
     - orderId
2287 
     - invoice_number
4658 mandeep.dh 2288 
     - serialNumber
4283 anupam.sin 2289 
     - itemNumber
3064 chandransh 2290 
     - billed_by
4264 rajveer 2291 
     - jacketNumber
4283 anupam.sin 2292 
     - billingType
5110 mandeep.dh 2293 
     - fulfilmentWarehouseId
4763 rajveer 2294 
     - authorize
1135 chandransh 2295 
    """
5110 mandeep.dh 2296 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2297 
    return self.recv_addBillingDetails()
1135 chandransh 2298 
 
5110 mandeep.dh 2299 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2300 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2301 
    args = addBillingDetails_args()
2302 
    args.orderId = orderId
2303 
    args.invoice_number = invoice_number
4658 mandeep.dh 2304 
    args.serialNumber = serialNumber
4283 anupam.sin 2305 
    args.itemNumber = itemNumber
3064 chandransh 2306 
    args.billed_by = billed_by
4264 rajveer 2307 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2308 
    args.billingType = billingType
5110 mandeep.dh 2309 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2310 
    args.authorize = authorize
1135 chandransh 2311 
    args.write(self._oprot)
2312 
    self._oprot.writeMessageEnd()
2313 
    self._oprot.trans.flush()
2314 
 
3064 chandransh 2315 
  def recv_addBillingDetails(self, ):
1135 chandransh 2316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2317 
    if mtype == TMessageType.EXCEPTION:
2318 
      x = TApplicationException()
2319 
      x.read(self._iprot)
2320 
      self._iprot.readMessageEnd()
2321 
      raise x
3064 chandransh 2322 
    result = addBillingDetails_result()
1135 chandransh 2323 
    result.read(self._iprot)
2324 
    self._iprot.readMessageEnd()
3431 rajveer 2325 
    if result.success is not None:
3064 chandransh 2326 
      return result.success
3431 rajveer 2327 
    if result.ex is not None:
1135 chandransh 2328 
      raise result.ex
3064 chandransh 2329 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2330 
 
4763 rajveer 2331 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2332 
    """
2333 
    Add the invoice number to the order.
2334 
 
2335 
    Parameters:
2336 
     - orderId
2337 
     - invoiceNumber
4763 rajveer 2338 
     - color
4579 rajveer 2339 
    """
4763 rajveer 2340 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2341 
    self.recv_addInvoiceNumber()
2342 
 
4763 rajveer 2343 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2344 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2345 
    args = addInvoiceNumber_args()
2346 
    args.orderId = orderId
2347 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2348 
    args.color = color
4579 rajveer 2349 
    args.write(self._oprot)
2350 
    self._oprot.writeMessageEnd()
2351 
    self._oprot.trans.flush()
2352 
 
2353 
  def recv_addInvoiceNumber(self, ):
2354 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2355 
    if mtype == TMessageType.EXCEPTION:
2356 
      x = TApplicationException()
2357 
      x.read(self._iprot)
2358 
      self._iprot.readMessageEnd()
2359 
      raise x
2360 
    result = addInvoiceNumber_result()
2361 
    result.read(self._iprot)
2362 
    self._iprot.readMessageEnd()
2363 
    if result.ex is not None:
2364 
      raise result.ex
2365 
    return
2366 
 
4910 phani.kuma 2367 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2368 
    """
3064 chandransh 2369 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2370 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2371 
 
1408 ankur.sing 2372 
    Parameters:
3064 chandransh 2373 
     - warehouseId
1408 ankur.sing 2374 
     - providerId
3064 chandransh 2375 
     - cod
4910 phani.kuma 2376 
     - orderIds
1408 ankur.sing 2377 
    """
4910 phani.kuma 2378 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2379 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2380 
 
4910 phani.kuma 2381 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2382 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2383 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2384 
    args.warehouseId = warehouseId
1408 ankur.sing 2385 
    args.providerId = providerId
3064 chandransh 2386 
    args.cod = cod
4910 phani.kuma 2387 
    args.orderIds = orderIds
1408 ankur.sing 2388 
    args.write(self._oprot)
2389 
    self._oprot.writeMessageEnd()
2390 
    self._oprot.trans.flush()
2391 
 
4910 phani.kuma 2392 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2393 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2394 
    if mtype == TMessageType.EXCEPTION:
2395 
      x = TApplicationException()
2396 
      x.read(self._iprot)
2397 
      self._iprot.readMessageEnd()
2398 
      raise x
4910 phani.kuma 2399 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2400 
    result.read(self._iprot)
2401 
    self._iprot.readMessageEnd()
3431 rajveer 2402 
    if result.success is not None:
1408 ankur.sing 2403 
      return result.success
3431 rajveer 2404 
    if result.ex is not None:
3064 chandransh 2405 
      raise result.ex
4910 phani.kuma 2406 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2407 
 
4910 phani.kuma 2408 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2409 
    """
4910 phani.kuma 2410 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2411 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2412 
 
2413 
    Parameters:
2414 
     - providerId
4910 phani.kuma 2415 
     - pickupDetails
4410 rajveer 2416 
    """
4910 phani.kuma 2417 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2418 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2419 
 
4910 phani.kuma 2420 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2421 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2422 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2423 
    args.providerId = providerId
4910 phani.kuma 2424 
    args.pickupDetails = pickupDetails
4410 rajveer 2425 
    args.write(self._oprot)
2426 
    self._oprot.writeMessageEnd()
2427 
    self._oprot.trans.flush()
2428 
 
4910 phani.kuma 2429 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2430 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2431 
    if mtype == TMessageType.EXCEPTION:
2432 
      x = TApplicationException()
2433 
      x.read(self._iprot)
2434 
      self._iprot.readMessageEnd()
2435 
      raise x
4910 phani.kuma 2436 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2437 
    result.read(self._iprot)
2438 
    self._iprot.readMessageEnd()
2439 
    if result.ex is not None:
2440 
      raise result.ex
4910 phani.kuma 2441 
    return
4410 rajveer 2442 
 
4910 phani.kuma 2443 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2444 
    """
3064 chandransh 2445 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2446 
 
94 ashish 2447 
    Parameters:
3064 chandransh 2448 
     - providerId
304 ashish 2449 
    """
4910 phani.kuma 2450 
    self.send_getOrdersNotPickedUp(providerId)
2451 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2452 
 
4910 phani.kuma 2453 
  def send_getOrdersNotPickedUp(self, providerId):
2454 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2455 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2456 
    args.providerId = providerId
304 ashish 2457 
    args.write(self._oprot)
2458 
    self._oprot.writeMessageEnd()
2459 
    self._oprot.trans.flush()
2460 
 
4910 phani.kuma 2461 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2462 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2463 
    if mtype == TMessageType.EXCEPTION:
2464 
      x = TApplicationException()
2465 
      x.read(self._iprot)
2466 
      self._iprot.readMessageEnd()
2467 
      raise x
4910 phani.kuma 2468 
    result = getOrdersNotPickedUp_result()
304 ashish 2469 
    result.read(self._iprot)
2470 
    self._iprot.readMessageEnd()
3431 rajveer 2471 
    if result.success is not None:
304 ashish 2472 
      return result.success
4910 phani.kuma 2473 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2474 
 
3064 chandransh 2475 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2476 
    """
3064 chandransh 2477 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2478 
    the name of the receiver.
2479 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2480 
 
304 ashish 2481 
    Parameters:
3064 chandransh 2482 
     - providerId
2483 
     - deliveredOrders
304 ashish 2484 
    """
3064 chandransh 2485 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2486 
    self.recv_markOrdersAsDelivered()
304 ashish 2487 
 
3064 chandransh 2488 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2489 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2490 
    args = markOrdersAsDelivered_args()
2491 
    args.providerId = providerId
2492 
    args.deliveredOrders = deliveredOrders
304 ashish 2493 
    args.write(self._oprot)
2494 
    self._oprot.writeMessageEnd()
2495 
    self._oprot.trans.flush()
2496 
 
3064 chandransh 2497 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2499 
    if mtype == TMessageType.EXCEPTION:
2500 
      x = TApplicationException()
2501 
      x.read(self._iprot)
2502 
      self._iprot.readMessageEnd()
2503 
      raise x
3064 chandransh 2504 
    result = markOrdersAsDelivered_result()
304 ashish 2505 
    result.read(self._iprot)
2506 
    self._iprot.readMessageEnd()
3431 rajveer 2507 
    if result.ex is not None:
3064 chandransh 2508 
      raise result.ex
304 ashish 2509 
    return
2510 
 
4910 phani.kuma 2511 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2512 
    """
4910 phani.kuma 2513 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2514 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2515 
 
3064 chandransh 2516 
    Parameters:
2517 
     - providerId
2518 
     - returnedOrders
1596 ankur.sing 2519 
    """
4910 phani.kuma 2520 
    self.send_markAsRTOrders(providerId, returnedOrders)
2521 
    self.recv_markAsRTOrders()
304 ashish 2522 
 
4910 phani.kuma 2523 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2524 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2525 
    args = markAsRTOrders_args()
3064 chandransh 2526 
    args.providerId = providerId
2527 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2528 
    args.write(self._oprot)
2529 
    self._oprot.writeMessageEnd()
2530 
    self._oprot.trans.flush()
2531 
 
4910 phani.kuma 2532 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2534 
    if mtype == TMessageType.EXCEPTION:
2535 
      x = TApplicationException()
2536 
      x.read(self._iprot)
2537 
      self._iprot.readMessageEnd()
2538 
      raise x
4910 phani.kuma 2539 
    result = markAsRTOrders_result()
1596 ankur.sing 2540 
    result.read(self._iprot)
2541 
    self._iprot.readMessageEnd()
3431 rajveer 2542 
    if result.ex is not None:
3064 chandransh 2543 
      raise result.ex
2544 
    return
1596 ankur.sing 2545 
 
4910 phani.kuma 2546 
  def getRTOrders(self, providerId):
2547 
    """
2548 
    Returns a list of orders that were returned by courier.
2549 
 
2550 
    Parameters:
2551 
     - providerId
2552 
    """
2553 
    self.send_getRTOrders(providerId)
2554 
    return self.recv_getRTOrders()
2555 
 
2556 
  def send_getRTOrders(self, providerId):
2557 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2558 
    args = getRTOrders_args()
2559 
    args.providerId = providerId
2560 
    args.write(self._oprot)
2561 
    self._oprot.writeMessageEnd()
2562 
    self._oprot.trans.flush()
2563 
 
2564 
  def recv_getRTOrders(self, ):
2565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2566 
    if mtype == TMessageType.EXCEPTION:
2567 
      x = TApplicationException()
2568 
      x.read(self._iprot)
2569 
      self._iprot.readMessageEnd()
2570 
      raise x
2571 
    result = getRTOrders_result()
2572 
    result.read(self._iprot)
2573 
    self._iprot.readMessageEnd()
2574 
    if result.success is not None:
2575 
      return result.success
2576 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2577 
 
3064 chandransh 2578 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2579 
    """
3064 chandransh 2580 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2581 
 
3064 chandransh 2582 
    Parameters:
2583 
     - providerId
2584 
     - undeliveredOrders
1627 ankur.sing 2585 
    """
3064 chandransh 2586 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2587 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2588 
 
3064 chandransh 2589 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2590 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2591 
    args = updateNonDeliveryReason_args()
2592 
    args.providerId = providerId
2593 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2594 
    args.write(self._oprot)
2595 
    self._oprot.writeMessageEnd()
2596 
    self._oprot.trans.flush()
2597 
 
3064 chandransh 2598 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2599 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2600 
    if mtype == TMessageType.EXCEPTION:
2601 
      x = TApplicationException()
2602 
      x.read(self._iprot)
2603 
      self._iprot.readMessageEnd()
2604 
      raise x
3064 chandransh 2605 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2606 
    result.read(self._iprot)
2607 
    self._iprot.readMessageEnd()
4910 phani.kuma 2608 
    if result.ex is not None:
2609 
      raise result.ex
2610 
    return
2611 
 
2612 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2613 
    """
2614 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2615 
 
2616 
    Parameters:
2617 
     - providerId
2618 
    """
2619 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2620 
    return self.recv_getNonDeliveredOrdersbyCourier()
2621 
 
2622 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2623 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2624 
    args = getNonDeliveredOrdersbyCourier_args()
2625 
    args.providerId = providerId
2626 
    args.write(self._oprot)
2627 
    self._oprot.writeMessageEnd()
2628 
    self._oprot.trans.flush()
2629 
 
2630 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2631 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2632 
    if mtype == TMessageType.EXCEPTION:
2633 
      x = TApplicationException()
2634 
      x.read(self._iprot)
2635 
      self._iprot.readMessageEnd()
2636 
      raise x
2637 
    result = getNonDeliveredOrdersbyCourier_result()
2638 
    result.read(self._iprot)
2639 
    self._iprot.readMessageEnd()
4581 phani.kuma 2640 
    if result.success is not None:
2641 
      return result.success
4910 phani.kuma 2642 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2643 
 
2644 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2645 
    """
2646 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2647 
 
2648 
    Parameters:
2649 
     - providerId
2650 
     - local_connected_orders
2651 
    """
2652 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2653 
    self.recv_markOrdersAsLocalConnected()
2654 
 
2655 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2656 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2657 
    args = markOrdersAsLocalConnected_args()
2658 
    args.providerId = providerId
2659 
    args.local_connected_orders = local_connected_orders
2660 
    args.write(self._oprot)
2661 
    self._oprot.writeMessageEnd()
2662 
    self._oprot.trans.flush()
2663 
 
2664 
  def recv_markOrdersAsLocalConnected(self, ):
2665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2666 
    if mtype == TMessageType.EXCEPTION:
2667 
      x = TApplicationException()
2668 
      x.read(self._iprot)
2669 
      self._iprot.readMessageEnd()
2670 
      raise x
2671 
    result = markOrdersAsLocalConnected_result()
2672 
    result.read(self._iprot)
2673 
    self._iprot.readMessageEnd()
3431 rajveer 2674 
    if result.ex is not None:
3064 chandransh 2675 
      raise result.ex
4910 phani.kuma 2676 
    return
1627 ankur.sing 2677 
 
4910 phani.kuma 2678 
  def getOrdersNotLocalConnected(self, providerId):
2679 
    """
2680 
    Returns a list of orders that were picked up or shipped but pending local connection.
2681 
 
2682 
    Parameters:
2683 
     - providerId
2684 
    """
2685 
    self.send_getOrdersNotLocalConnected(providerId)
2686 
    return self.recv_getOrdersNotLocalConnected()
2687 
 
2688 
  def send_getOrdersNotLocalConnected(self, providerId):
2689 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2690 
    args = getOrdersNotLocalConnected_args()
2691 
    args.providerId = providerId
2692 
    args.write(self._oprot)
2693 
    self._oprot.writeMessageEnd()
2694 
    self._oprot.trans.flush()
2695 
 
2696 
  def recv_getOrdersNotLocalConnected(self, ):
2697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2698 
    if mtype == TMessageType.EXCEPTION:
2699 
      x = TApplicationException()
2700 
      x.read(self._iprot)
2701 
      self._iprot.readMessageEnd()
2702 
      raise x
2703 
    result = getOrdersNotLocalConnected_result()
2704 
    result.read(self._iprot)
2705 
    self._iprot.readMessageEnd()
2706 
    if result.success is not None:
2707 
      return result.success
2708 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2709 
 
2710 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2711 
    """
2712 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2713 
 
2714 
    Parameters:
2715 
     - providerId
2716 
     - destination_city_reached_orders
2717 
    """
2718 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2719 
    self.recv_markOrdersAsDestinationCityReached()
2720 
 
2721 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2722 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2723 
    args = markOrdersAsDestinationCityReached_args()
2724 
    args.providerId = providerId
2725 
    args.destination_city_reached_orders = destination_city_reached_orders
2726 
    args.write(self._oprot)
2727 
    self._oprot.writeMessageEnd()
2728 
    self._oprot.trans.flush()
2729 
 
2730 
  def recv_markOrdersAsDestinationCityReached(self, ):
2731 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2732 
    if mtype == TMessageType.EXCEPTION:
2733 
      x = TApplicationException()
2734 
      x.read(self._iprot)
2735 
      self._iprot.readMessageEnd()
2736 
      raise x
2737 
    result = markOrdersAsDestinationCityReached_result()
2738 
    result.read(self._iprot)
2739 
    self._iprot.readMessageEnd()
2740 
    if result.ex is not None:
2741 
      raise result.ex
2742 
    return
2743 
 
2744 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2745 
    """
2746 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
2747 
 
2748 
    Parameters:
2749 
     - providerId
2750 
     - first_atdl_orders
2751 
    """
2752 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
2753 
    self.recv_markOrdersAsFirstDeliveryAttempted()
2754 
 
2755 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2756 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
2757 
    args = markOrdersAsFirstDeliveryAttempted_args()
2758 
    args.providerId = providerId
2759 
    args.first_atdl_orders = first_atdl_orders
2760 
    args.write(self._oprot)
2761 
    self._oprot.writeMessageEnd()
2762 
    self._oprot.trans.flush()
2763 
 
2764 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
2765 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2766 
    if mtype == TMessageType.EXCEPTION:
2767 
      x = TApplicationException()
2768 
      x.read(self._iprot)
2769 
      self._iprot.readMessageEnd()
2770 
      raise x
2771 
    result = markOrdersAsFirstDeliveryAttempted_result()
2772 
    result.read(self._iprot)
2773 
    self._iprot.readMessageEnd()
2774 
    if result.ex is not None:
2775 
      raise result.ex
2776 
    return
2777 
 
3064 chandransh 2778 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2779 
    """
3064 chandransh 2780 
    Returns the list of orders whose delivery time has passed but have not been
2781 
    delivered yet for the given provider and warehouse. To get a complete list of
2782 
    undelivered orders, pass them as -1.
2783 
    Returns an empty list if no such orders exist.
3431 rajveer 2784 
 
1886 ankur.sing 2785 
    Parameters:
3064 chandransh 2786 
     - providerId
2787 
     - warehouseId
1886 ankur.sing 2788 
    """
3064 chandransh 2789 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2790 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2791 
 
3064 chandransh 2792 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2793 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2794 
    args = getUndeliveredOrders_args()
2795 
    args.providerId = providerId
2796 
    args.warehouseId = warehouseId
1886 ankur.sing 2797 
    args.write(self._oprot)
2798 
    self._oprot.writeMessageEnd()
2799 
    self._oprot.trans.flush()
2800 
 
3064 chandransh 2801 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2803 
    if mtype == TMessageType.EXCEPTION:
2804 
      x = TApplicationException()
2805 
      x.read(self._iprot)
2806 
      self._iprot.readMessageEnd()
2807 
      raise x
3064 chandransh 2808 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2809 
    result.read(self._iprot)
2810 
    self._iprot.readMessageEnd()
3431 rajveer 2811 
    if result.success is not None:
1886 ankur.sing 2812 
      return result.success
3064 chandransh 2813 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2814 
 
4783 phani.kuma 2815 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2816 
    """
2817 
    Returns the list of orders whose expected delivery date has passed but have not been
2818 
    delivered yet.
2819 
    Returns an empty list if no such orders exist.
2820 
    """
2821 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2822 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2823 
 
2824 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2825 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2826 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2827 
    args.write(self._oprot)
2828 
    self._oprot.writeMessageEnd()
2829 
    self._oprot.trans.flush()
2830 
 
2831 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2832 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2833 
    if mtype == TMessageType.EXCEPTION:
2834 
      x = TApplicationException()
2835 
      x.read(self._iprot)
2836 
      self._iprot.readMessageEnd()
2837 
      raise x
2838 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2839 
    result.read(self._iprot)
2840 
    self._iprot.readMessageEnd()
2841 
    if result.success is not None:
2842 
      return result.success
2843 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2844 
 
2536 chandransh 2845 
  def toggleDOAFlag(self, orderId):
2846 
    """
2847 
    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.
2848 
    Returns the final flag status.
2849 
    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 2850 
 
2536 chandransh 2851 
    Parameters:
2852 
     - orderId
2853 
    """
2854 
    self.send_toggleDOAFlag(orderId)
2855 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2856 
 
2536 chandransh 2857 
  def send_toggleDOAFlag(self, orderId):
2858 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2859 
    args = toggleDOAFlag_args()
2860 
    args.orderId = orderId
2861 
    args.write(self._oprot)
2862 
    self._oprot.writeMessageEnd()
2863 
    self._oprot.trans.flush()
2864 
 
2865 
  def recv_toggleDOAFlag(self, ):
2866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2867 
    if mtype == TMessageType.EXCEPTION:
2868 
      x = TApplicationException()
2869 
      x.read(self._iprot)
2870 
      self._iprot.readMessageEnd()
2871 
      raise x
2872 
    result = toggleDOAFlag_result()
2873 
    result.read(self._iprot)
2874 
    self._iprot.readMessageEnd()
3431 rajveer 2875 
    if result.success is not None:
2536 chandransh 2876 
      return result.success
3431 rajveer 2877 
    if result.ex is not None:
2536 chandransh 2878 
      raise result.ex
2879 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2880 
 
4712 rajveer 2881 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2882 
    """
2883 
    Parameters:
2884 
     - orderId
2885 
     - deliveryTimestamp
2886 
     - receiver
2887 
    """
2888 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2889 
    self.recv_markOrderAsDelivered()
2890 
 
2891 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2892 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2893 
    args = markOrderAsDelivered_args()
2894 
    args.orderId = orderId
2895 
    args.deliveryTimestamp = deliveryTimestamp
2896 
    args.receiver = receiver
2897 
    args.write(self._oprot)
2898 
    self._oprot.writeMessageEnd()
2899 
    self._oprot.trans.flush()
2900 
 
2901 
  def recv_markOrderAsDelivered(self, ):
2902 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2903 
    if mtype == TMessageType.EXCEPTION:
2904 
      x = TApplicationException()
2905 
      x.read(self._iprot)
2906 
      self._iprot.readMessageEnd()
2907 
      raise x
2908 
    result = markOrderAsDelivered_result()
2909 
    result.read(self._iprot)
2910 
    self._iprot.readMessageEnd()
2911 
    if result.ex is not None:
2912 
      raise result.ex
2913 
    return
2914 
 
4454 rajveer 2915 
  def markOrderDoaRequestReceived(self, orderId):
2916 
    """
2917 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2918 
 
2919 
    Parameters:
2920 
     - orderId
2921 
    """
2922 
    self.send_markOrderDoaRequestReceived(orderId)
2923 
    return self.recv_markOrderDoaRequestReceived()
2924 
 
2925 
  def send_markOrderDoaRequestReceived(self, orderId):
2926 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2927 
    args = markOrderDoaRequestReceived_args()
2928 
    args.orderId = orderId
2929 
    args.write(self._oprot)
2930 
    self._oprot.writeMessageEnd()
2931 
    self._oprot.trans.flush()
2932 
 
2933 
  def recv_markOrderDoaRequestReceived(self, ):
2934 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2935 
    if mtype == TMessageType.EXCEPTION:
2936 
      x = TApplicationException()
2937 
      x.read(self._iprot)
2938 
      self._iprot.readMessageEnd()
2939 
      raise x
2940 
    result = markOrderDoaRequestReceived_result()
2941 
    result.read(self._iprot)
2942 
    self._iprot.readMessageEnd()
2943 
    if result.success is not None:
2944 
      return result.success
2945 
    if result.ex is not None:
2946 
      raise result.ex
2947 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2948 
 
2949 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2950 
    """
2951 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2952 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2953 
 
2954 
    Parameters:
2955 
     - orderId
2956 
     - isAuthorized
2957 
    """
2958 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2959 
    return self.recv_markOrderDoaRequestAuthorized()
2960 
 
2961 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2962 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2963 
    args = markOrderDoaRequestAuthorized_args()
2964 
    args.orderId = orderId
2965 
    args.isAuthorized = isAuthorized
2966 
    args.write(self._oprot)
2967 
    self._oprot.writeMessageEnd()
2968 
    self._oprot.trans.flush()
2969 
 
2970 
  def recv_markOrderDoaRequestAuthorized(self, ):
2971 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2972 
    if mtype == TMessageType.EXCEPTION:
2973 
      x = TApplicationException()
2974 
      x.read(self._iprot)
2975 
      self._iprot.readMessageEnd()
2976 
      raise x
2977 
    result = markOrderDoaRequestAuthorized_result()
2978 
    result.read(self._iprot)
2979 
    self._iprot.readMessageEnd()
2980 
    if result.success is not None:
2981 
      return result.success
2982 
    if result.ex is not None:
2983 
      raise result.ex
2984 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2985 
 
4488 rajveer 2986 
  def markOrderReturnRequestReceived(self, orderId):
2987 
    """
2988 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2989 
 
2990 
    Parameters:
2991 
     - orderId
2992 
    """
2993 
    self.send_markOrderReturnRequestReceived(orderId)
2994 
    return self.recv_markOrderReturnRequestReceived()
2995 
 
2996 
  def send_markOrderReturnRequestReceived(self, orderId):
2997 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2998 
    args = markOrderReturnRequestReceived_args()
2999 
    args.orderId = orderId
3000 
    args.write(self._oprot)
3001 
    self._oprot.writeMessageEnd()
3002 
    self._oprot.trans.flush()
3003 
 
3004 
  def recv_markOrderReturnRequestReceived(self, ):
3005 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3006 
    if mtype == TMessageType.EXCEPTION:
3007 
      x = TApplicationException()
3008 
      x.read(self._iprot)
3009 
      self._iprot.readMessageEnd()
3010 
      raise x
3011 
    result = markOrderReturnRequestReceived_result()
3012 
    result.read(self._iprot)
3013 
    self._iprot.readMessageEnd()
3014 
    if result.success is not None:
3015 
      return result.success
3016 
    if result.ex is not None:
3017 
      raise result.ex
3018 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3019 
 
3020 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3021 
    """
3022 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3023 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3024 
 
3025 
    Parameters:
3026 
     - orderId
3027 
     - isAuthorized
3028 
    """
3029 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3030 
    return self.recv_markOrderReturnRequestAuthorized()
3031 
 
3032 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3033 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3034 
    args = markOrderReturnRequestAuthorized_args()
3035 
    args.orderId = orderId
3036 
    args.isAuthorized = isAuthorized
3037 
    args.write(self._oprot)
3038 
    self._oprot.writeMessageEnd()
3039 
    self._oprot.trans.flush()
3040 
 
3041 
  def recv_markOrderReturnRequestAuthorized(self, ):
3042 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3043 
    if mtype == TMessageType.EXCEPTION:
3044 
      x = TApplicationException()
3045 
      x.read(self._iprot)
3046 
      self._iprot.readMessageEnd()
3047 
      raise x
3048 
    result = markOrderReturnRequestAuthorized_result()
3049 
    result.read(self._iprot)
3050 
    self._iprot.readMessageEnd()
3051 
    if result.success is not None:
3052 
      return result.success
3053 
    if result.ex is not None:
3054 
      raise result.ex
3055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3056 
 
4579 rajveer 3057 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3058 
    """
3059 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3060 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3061 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3062 
    For any other status, it returns false.
3063 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3064 
 
2536 chandransh 3065 
    Parameters:
3066 
     - orderId
4579 rajveer 3067 
     - providerId
2536 chandransh 3068 
    """
4579 rajveer 3069 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3070 
    return self.recv_requestPickupNumber()
3071 
 
4579 rajveer 3072 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3073 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3074 
    args = requestPickupNumber_args()
3075 
    args.orderId = orderId
4579 rajveer 3076 
    args.providerId = providerId
2536 chandransh 3077 
    args.write(self._oprot)
3078 
    self._oprot.writeMessageEnd()
3079 
    self._oprot.trans.flush()
3080 
 
3081 
  def recv_requestPickupNumber(self, ):
3082 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3083 
    if mtype == TMessageType.EXCEPTION:
3084 
      x = TApplicationException()
3085 
      x.read(self._iprot)
3086 
      self._iprot.readMessageEnd()
3087 
      raise x
3088 
    result = requestPickupNumber_result()
3089 
    result.read(self._iprot)
3090 
    self._iprot.readMessageEnd()
3431 rajveer 3091 
    if result.success is not None:
2536 chandransh 3092 
      return result.success
3431 rajveer 3093 
    if result.ex is not None:
2536 chandransh 3094 
      raise result.ex
3095 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3096 
 
4602 rajveer 3097 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3098 
    """
4452 rajveer 3099 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3100 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3101 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3102 
    	3. Returns true
2591 chandransh 3103 
    If the order is in any other status, it returns false.
2536 chandransh 3104 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3105 
 
2536 chandransh 3106 
    Parameters:
3107 
     - orderId
3108 
     - pickupNumber
4602 rajveer 3109 
     - providerId
2536 chandransh 3110 
    """
4602 rajveer 3111 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3112 
    return self.recv_authorizePickup()
3113 
 
4602 rajveer 3114 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3115 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3116 
    args = authorizePickup_args()
3117 
    args.orderId = orderId
3118 
    args.pickupNumber = pickupNumber
4602 rajveer 3119 
    args.providerId = providerId
2536 chandransh 3120 
    args.write(self._oprot)
3121 
    self._oprot.writeMessageEnd()
3122 
    self._oprot.trans.flush()
3123 
 
3124 
  def recv_authorizePickup(self, ):
3125 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3126 
    if mtype == TMessageType.EXCEPTION:
3127 
      x = TApplicationException()
3128 
      x.read(self._iprot)
3129 
      self._iprot.readMessageEnd()
3130 
      raise x
3131 
    result = authorizePickup_result()
3132 
    result.read(self._iprot)
3133 
    self._iprot.readMessageEnd()
3431 rajveer 3134 
    if result.success is not None:
2536 chandransh 3135 
      return result.success
3431 rajveer 3136 
    if result.ex is not None:
2536 chandransh 3137 
      raise result.ex
3138 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3139 
 
2764 chandransh 3140 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3141 
    """
3142 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3143 
 
2764 chandransh 3144 
    Parameters:
3145 
     - providerId
3146 
     - pickupDetails
3147 
    """
3148 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3149 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3150 
 
3151 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3152 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3153 
    args = markDoasAsPickedUp_args()
3154 
    args.providerId = providerId
3155 
    args.pickupDetails = pickupDetails
3156 
    args.write(self._oprot)
3157 
    self._oprot.writeMessageEnd()
3158 
    self._oprot.trans.flush()
3159 
 
3160 
  def recv_markDoasAsPickedUp(self, ):
3161 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3162 
    if mtype == TMessageType.EXCEPTION:
3163 
      x = TApplicationException()
3164 
      x.read(self._iprot)
3165 
      self._iprot.readMessageEnd()
3166 
      raise x
3167 
    result = markDoasAsPickedUp_result()
3168 
    result.read(self._iprot)
3169 
    self._iprot.readMessageEnd()
4910 phani.kuma 3170 
    return
3171 
 
3172 
  def getDoasNotPickedUp(self, providerId):
3173 
    """
3174 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3175 
 
3176 
    Parameters:
3177 
     - providerId
3178 
    """
3179 
    self.send_getDoasNotPickedUp(providerId)
3180 
    return self.recv_getDoasNotPickedUp()
3181 
 
3182 
  def send_getDoasNotPickedUp(self, providerId):
3183 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3184 
    args = getDoasNotPickedUp_args()
3185 
    args.providerId = providerId
3186 
    args.write(self._oprot)
3187 
    self._oprot.writeMessageEnd()
3188 
    self._oprot.trans.flush()
3189 
 
3190 
  def recv_getDoasNotPickedUp(self, ):
3191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3192 
    if mtype == TMessageType.EXCEPTION:
3193 
      x = TApplicationException()
3194 
      x.read(self._iprot)
3195 
      self._iprot.readMessageEnd()
3196 
      raise x
3197 
    result = getDoasNotPickedUp_result()
3198 
    result.read(self._iprot)
3199 
    self._iprot.readMessageEnd()
3431 rajveer 3200 
    if result.success is not None:
2764 chandransh 3201 
      return result.success
4910 phani.kuma 3202 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3203 
 
4741 phani.kuma 3204 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3205 
    """
3206 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3207 
 
3208 
    Parameters:
3209 
     - providerId
3210 
     - pickupDetails
3211 
    """
3212 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3213 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3214 
 
3215 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3216 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3217 
    args = markReturnOrdersAsPickedUp_args()
3218 
    args.providerId = providerId
3219 
    args.pickupDetails = pickupDetails
3220 
    args.write(self._oprot)
3221 
    self._oprot.writeMessageEnd()
3222 
    self._oprot.trans.flush()
3223 
 
3224 
  def recv_markReturnOrdersAsPickedUp(self, ):
3225 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3226 
    if mtype == TMessageType.EXCEPTION:
3227 
      x = TApplicationException()
3228 
      x.read(self._iprot)
3229 
      self._iprot.readMessageEnd()
3230 
      raise x
3231 
    result = markReturnOrdersAsPickedUp_result()
3232 
    result.read(self._iprot)
3233 
    self._iprot.readMessageEnd()
4910 phani.kuma 3234 
    return
3235 
 
3236 
  def getReturnOrdersNotPickedUp(self, providerId):
3237 
    """
3238 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3239 
 
3240 
    Parameters:
3241 
     - providerId
3242 
    """
3243 
    self.send_getReturnOrdersNotPickedUp(providerId)
3244 
    return self.recv_getReturnOrdersNotPickedUp()
3245 
 
3246 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3247 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3248 
    args = getReturnOrdersNotPickedUp_args()
3249 
    args.providerId = providerId
3250 
    args.write(self._oprot)
3251 
    self._oprot.writeMessageEnd()
3252 
    self._oprot.trans.flush()
3253 
 
3254 
  def recv_getReturnOrdersNotPickedUp(self, ):
3255 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3256 
    if mtype == TMessageType.EXCEPTION:
3257 
      x = TApplicationException()
3258 
      x.read(self._iprot)
3259 
      self._iprot.readMessageEnd()
3260 
      raise x
3261 
    result = getReturnOrdersNotPickedUp_result()
3262 
    result.read(self._iprot)
3263 
    self._iprot.readMessageEnd()
4741 phani.kuma 3264 
    if result.success is not None:
3265 
      return result.success
4910 phani.kuma 3266 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3267 
 
4479 rajveer 3268 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3269 
    """
4452 rajveer 3270 
    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 3271 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3272 
    If the order is in any other state, it returns false.
3273 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3274 
 
2591 chandransh 3275 
    Parameters:
3276 
     - orderId
4479 rajveer 3277 
     - receiveCondition
2591 chandransh 3278 
    """
4479 rajveer 3279 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3280 
    return self.recv_receiveReturn()
2536 chandransh 3281 
 
4479 rajveer 3282 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3283 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3284 
    args = receiveReturn_args()
2591 chandransh 3285 
    args.orderId = orderId
4479 rajveer 3286 
    args.receiveCondition = receiveCondition
2591 chandransh 3287 
    args.write(self._oprot)
3288 
    self._oprot.writeMessageEnd()
3289 
    self._oprot.trans.flush()
3290 
 
2616 chandransh 3291 
  def recv_receiveReturn(self, ):
2591 chandransh 3292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3293 
    if mtype == TMessageType.EXCEPTION:
3294 
      x = TApplicationException()
3295 
      x.read(self._iprot)
3296 
      self._iprot.readMessageEnd()
3297 
      raise x
2616 chandransh 3298 
    result = receiveReturn_result()
2591 chandransh 3299 
    result.read(self._iprot)
3300 
    self._iprot.readMessageEnd()
3431 rajveer 3301 
    if result.success is not None:
2591 chandransh 3302 
      return result.success
3431 rajveer 3303 
    if result.ex is not None:
2591 chandransh 3304 
      raise result.ex
2616 chandransh 3305 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3306 
 
3307 
  def validateDoa(self, orderId, isValid):
3308 
    """
4452 rajveer 3309 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3310 
    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 3311 
    If the order is in any other state, it returns false.
3312 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3313 
 
2591 chandransh 3314 
    Parameters:
3315 
     - orderId
3316 
     - isValid
3317 
    """
3318 
    self.send_validateDoa(orderId, isValid)
3319 
    return self.recv_validateDoa()
3320 
 
3321 
  def send_validateDoa(self, orderId, isValid):
3322 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3323 
    args = validateDoa_args()
3324 
    args.orderId = orderId
3325 
    args.isValid = isValid
3326 
    args.write(self._oprot)
3327 
    self._oprot.writeMessageEnd()
3328 
    self._oprot.trans.flush()
3329 
 
3330 
  def recv_validateDoa(self, ):
3331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3332 
    if mtype == TMessageType.EXCEPTION:
3333 
      x = TApplicationException()
3334 
      x.read(self._iprot)
3335 
      self._iprot.readMessageEnd()
3336 
      raise x
3337 
    result = validateDoa_result()
3338 
    result.read(self._iprot)
3339 
    self._iprot.readMessageEnd()
3431 rajveer 3340 
    if result.success is not None:
2591 chandransh 3341 
      return result.success
3431 rajveer 3342 
    if result.ex is not None:
2591 chandransh 3343 
      raise result.ex
3344 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3345 
 
4495 rajveer 3346 
  def validateReturnProduct(self, orderId, isUsable):
3347 
    """
3348 
    Parameters:
3349 
     - orderId
3350 
     - isUsable
3351 
    """
3352 
    self.send_validateReturnProduct(orderId, isUsable)
3353 
    return self.recv_validateReturnProduct()
3354 
 
3355 
  def send_validateReturnProduct(self, orderId, isUsable):
3356 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3357 
    args = validateReturnProduct_args()
3358 
    args.orderId = orderId
3359 
    args.isUsable = isUsable
3360 
    args.write(self._oprot)
3361 
    self._oprot.writeMessageEnd()
3362 
    self._oprot.trans.flush()
3363 
 
3364 
  def recv_validateReturnProduct(self, ):
3365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3366 
    if mtype == TMessageType.EXCEPTION:
3367 
      x = TApplicationException()
3368 
      x.read(self._iprot)
3369 
      self._iprot.readMessageEnd()
3370 
      raise x
3371 
    result = validateReturnProduct_result()
3372 
    result.read(self._iprot)
3373 
    self._iprot.readMessageEnd()
3374 
    if result.success is not None:
3375 
      return result.success
3376 
    if result.ex is not None:
3377 
      raise result.ex
3378 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3379 
 
2616 chandransh 3380 
  def reshipOrder(self, orderId):
3381 
    """
4484 rajveer 3382 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3383 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3384 
    	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 3385 
 
3386 
    If the order is in DOA_CERT_VALID state, it does the following:
3387 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3388 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3389 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3390 
 
2616 chandransh 3391 
    Returns the id of the newly created order.
3431 rajveer 3392 
 
2616 chandransh 3393 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3394 
 
2616 chandransh 3395 
    Parameters:
3396 
     - orderId
3397 
    """
3398 
    self.send_reshipOrder(orderId)
3399 
    return self.recv_reshipOrder()
2591 chandransh 3400 
 
2616 chandransh 3401 
  def send_reshipOrder(self, orderId):
3402 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3403 
    args = reshipOrder_args()
3404 
    args.orderId = orderId
3405 
    args.write(self._oprot)
3406 
    self._oprot.writeMessageEnd()
3407 
    self._oprot.trans.flush()
3408 
 
3409 
  def recv_reshipOrder(self, ):
3410 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3411 
    if mtype == TMessageType.EXCEPTION:
3412 
      x = TApplicationException()
3413 
      x.read(self._iprot)
3414 
      self._iprot.readMessageEnd()
3415 
      raise x
3416 
    result = reshipOrder_result()
3417 
    result.read(self._iprot)
3418 
    self._iprot.readMessageEnd()
3431 rajveer 3419 
    if result.success is not None:
2616 chandransh 3420 
      return result.success
3431 rajveer 3421 
    if result.ex is not None:
2616 chandransh 3422 
      raise result.ex
3423 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3424 
 
3226 chandransh 3425 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3426 
    """
4484 rajveer 3427 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3428 
    	1. Creates a refund request for batch processing.
3429 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3430 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3431 
 
2616 chandransh 3432 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3433 
    	1. Creates a refund request for batch processing.
3226 chandransh 3434 
    	2. Cancels the reservation of the item in the warehouse.
3435 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3436 
 
3226 chandransh 3437 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3438 
    	1. Cancels the reservation of the item in the warehouse.
3439 
    	2. Marks the current order as CANCELED.
3440 
 
3441 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3442 
 
2616 chandransh 3443 
    Returns True if it is successful, False otherwise.
3431 rajveer 3444 
 
2616 chandransh 3445 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3446 
 
2616 chandransh 3447 
    Parameters:
3448 
     - orderId
3226 chandransh 3449 
     - refundedBy
3450 
     - reason
2616 chandransh 3451 
    """
3226 chandransh 3452 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3453 
    return self.recv_refundOrder()
3454 
 
3226 chandransh 3455 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3456 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3457 
    args = refundOrder_args()
3458 
    args.orderId = orderId
3226 chandransh 3459 
    args.refundedBy = refundedBy
3460 
    args.reason = reason
2616 chandransh 3461 
    args.write(self._oprot)
3462 
    self._oprot.writeMessageEnd()
3463 
    self._oprot.trans.flush()
3464 
 
3465 
  def recv_refundOrder(self, ):
3466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3467 
    if mtype == TMessageType.EXCEPTION:
3468 
      x = TApplicationException()
3469 
      x.read(self._iprot)
3470 
      self._iprot.readMessageEnd()
3471 
      raise x
3472 
    result = refundOrder_result()
3473 
    result.read(self._iprot)
3474 
    self._iprot.readMessageEnd()
3431 rajveer 3475 
    if result.success is not None:
2616 chandransh 3476 
      return result.success
3431 rajveer 3477 
    if result.ex is not None:
2616 chandransh 3478 
      raise result.ex
3479 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3480 
 
2690 chandransh 3481 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3482 
    """
3483 
    Get all return orders created between the from and to dates for the given warehouse.
3484 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3485 
 
2690 chandransh 3486 
    Parameters:
3487 
     - warehouseId
3488 
     - fromDate
3489 
     - toDate
3490 
    """
3491 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3492 
    return self.recv_getReturnOrders()
2616 chandransh 3493 
 
2690 chandransh 3494 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3495 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3496 
    args = getReturnOrders_args()
3497 
    args.warehouseId = warehouseId
3498 
    args.fromDate = fromDate
3499 
    args.toDate = toDate
3500 
    args.write(self._oprot)
3501 
    self._oprot.writeMessageEnd()
3502 
    self._oprot.trans.flush()
3503 
 
3504 
  def recv_getReturnOrders(self, ):
3505 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3506 
    if mtype == TMessageType.EXCEPTION:
3507 
      x = TApplicationException()
3508 
      x.read(self._iprot)
3509 
      self._iprot.readMessageEnd()
3510 
      raise x
3511 
    result = getReturnOrders_result()
3512 
    result.read(self._iprot)
3513 
    self._iprot.readMessageEnd()
3431 rajveer 3514 
    if result.success is not None:
2690 chandransh 3515 
      return result.success
3516 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3517 
 
2700 chandransh 3518 
  def getReturnOrder(self, id):
3519 
    """
3520 
    Returns the ReturnOrder corresponding to the given id.
3521 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3522 
 
2700 chandransh 3523 
    Parameters:
3524 
     - id
3525 
    """
3526 
    self.send_getReturnOrder(id)
3527 
    return self.recv_getReturnOrder()
3528 
 
3529 
  def send_getReturnOrder(self, id):
3530 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3531 
    args = getReturnOrder_args()
3532 
    args.id = id
3533 
    args.write(self._oprot)
3534 
    self._oprot.writeMessageEnd()
3535 
    self._oprot.trans.flush()
3536 
 
3537 
  def recv_getReturnOrder(self, ):
3538 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3539 
    if mtype == TMessageType.EXCEPTION:
3540 
      x = TApplicationException()
3541 
      x.read(self._iprot)
3542 
      self._iprot.readMessageEnd()
3543 
      raise x
3544 
    result = getReturnOrder_result()
3545 
    result.read(self._iprot)
3546 
    self._iprot.readMessageEnd()
3431 rajveer 3547 
    if result.success is not None:
2700 chandransh 3548 
      return result.success
3431 rajveer 3549 
    if result.ex is not None:
2700 chandransh 3550 
      raise result.ex
3551 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3552 
 
2690 chandransh 3553 
  def processReturn(self, returnOrderId):
3554 
    """
3555 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3556 
 
2690 chandransh 3557 
    Parameters:
3558 
     - returnOrderId
3559 
    """
3560 
    self.send_processReturn(returnOrderId)
3561 
    self.recv_processReturn()
3562 
 
3563 
  def send_processReturn(self, returnOrderId):
3564 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3565 
    args = processReturn_args()
3566 
    args.returnOrderId = returnOrderId
3567 
    args.write(self._oprot)
3568 
    self._oprot.writeMessageEnd()
3569 
    self._oprot.trans.flush()
3570 
 
3571 
  def recv_processReturn(self, ):
3572 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3573 
    if mtype == TMessageType.EXCEPTION:
3574 
      x = TApplicationException()
3575 
      x.read(self._iprot)
3576 
      self._iprot.readMessageEnd()
3577 
      raise x
3578 
    result = processReturn_result()
3579 
    result.read(self._iprot)
3580 
    self._iprot.readMessageEnd()
3431 rajveer 3581 
    if result.ex is not None:
2690 chandransh 3582 
      raise result.ex
3583 
    return
3584 
 
3451 chandransh 3585 
  def updateWeight(self, orderId, weight):
3586 
    """
3587 
    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 3588 
 
3451 chandransh 3589 
    Parameters:
3590 
     - orderId
3591 
     - weight
3592 
    """
3593 
    self.send_updateWeight(orderId, weight)
3594 
    return self.recv_updateWeight()
3595 
 
3596 
  def send_updateWeight(self, orderId, weight):
3597 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3598 
    args = updateWeight_args()
3599 
    args.orderId = orderId
3600 
    args.weight = weight
3601 
    args.write(self._oprot)
3602 
    self._oprot.writeMessageEnd()
3603 
    self._oprot.trans.flush()
3604 
 
3605 
  def recv_updateWeight(self, ):
3606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3607 
    if mtype == TMessageType.EXCEPTION:
3608 
      x = TApplicationException()
3609 
      x.read(self._iprot)
3610 
      self._iprot.readMessageEnd()
3611 
      raise x
3612 
    result = updateWeight_result()
3613 
    result.read(self._iprot)
3614 
    self._iprot.readMessageEnd()
3615 
    if result.success is not None:
3616 
      return result.success
3617 
    if result.ex is not None:
3618 
      raise result.ex
3619 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3620 
 
3469 chandransh 3621 
  def changeItem(self, orderId, itemId):
3622 
    """
3623 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3624 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3625 
 
3469 chandransh 3626 
    Parameters:
3627 
     - orderId
3628 
     - itemId
3629 
    """
3630 
    self.send_changeItem(orderId, itemId)
3631 
    return self.recv_changeItem()
3632 
 
3633 
  def send_changeItem(self, orderId, itemId):
3634 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3635 
    args = changeItem_args()
3636 
    args.orderId = orderId
3637 
    args.itemId = itemId
3638 
    args.write(self._oprot)
3639 
    self._oprot.writeMessageEnd()
3640 
    self._oprot.trans.flush()
3641 
 
3642 
  def recv_changeItem(self, ):
3643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3644 
    if mtype == TMessageType.EXCEPTION:
3645 
      x = TApplicationException()
3646 
      x.read(self._iprot)
3647 
      self._iprot.readMessageEnd()
3648 
      raise x
3649 
    result = changeItem_result()
3650 
    result.read(self._iprot)
3651 
    self._iprot.readMessageEnd()
3652 
    if result.success is not None:
3653 
      return result.success
3654 
    if result.ex is not None:
3655 
      raise result.ex
3656 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3657 
 
3658 
  def shiftToWarehouse(self, orderId, warehouseId):
3659 
    """
3660 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3661 
 
3662 
    Parameters:
3663 
     - orderId
3664 
     - warehouseId
3665 
    """
3666 
    self.send_shiftToWarehouse(orderId, warehouseId)
3667 
    return self.recv_shiftToWarehouse()
3668 
 
3669 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3670 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3671 
    args = shiftToWarehouse_args()
3672 
    args.orderId = orderId
3673 
    args.warehouseId = warehouseId
3674 
    args.write(self._oprot)
3675 
    self._oprot.writeMessageEnd()
3676 
    self._oprot.trans.flush()
3677 
 
3678 
  def recv_shiftToWarehouse(self, ):
3679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3680 
    if mtype == TMessageType.EXCEPTION:
3681 
      x = TApplicationException()
3682 
      x.read(self._iprot)
3683 
      self._iprot.readMessageEnd()
3684 
      raise x
3685 
    result = shiftToWarehouse_result()
3686 
    result.read(self._iprot)
3687 
    self._iprot.readMessageEnd()
3688 
    if result.success is not None:
3689 
      return result.success
3690 
    if result.ex is not None:
3691 
      raise result.ex
3692 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3693 
 
4647 rajveer 3694 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3695 
    """
3696 
    Adds the given delay reason to the given order.
3986 chandransh 3697 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3698 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3699 
 
3553 chandransh 3700 
    Parameters:
3701 
     - orderId
3702 
     - delayReason
3986 chandransh 3703 
     - furtherDelay
4647 rajveer 3704 
     - delayReasonText
3553 chandransh 3705 
    """
4647 rajveer 3706 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3707 
    return self.recv_addDelayReason()
3708 
 
4647 rajveer 3709 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3710 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3711 
    args = addDelayReason_args()
3712 
    args.orderId = orderId
3713 
    args.delayReason = delayReason
3986 chandransh 3714 
    args.furtherDelay = furtherDelay
4647 rajveer 3715 
    args.delayReasonText = delayReasonText
3553 chandransh 3716 
    args.write(self._oprot)
3717 
    self._oprot.writeMessageEnd()
3718 
    self._oprot.trans.flush()
3719 
 
3720 
  def recv_addDelayReason(self, ):
3721 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3722 
    if mtype == TMessageType.EXCEPTION:
3723 
      x = TApplicationException()
3724 
      x.read(self._iprot)
3725 
      self._iprot.readMessageEnd()
3726 
      raise x
3727 
    result = addDelayReason_result()
3728 
    result.read(self._iprot)
3729 
    self._iprot.readMessageEnd()
3730 
    if result.success is not None:
3731 
      return result.success
3732 
    if result.ex is not None:
3733 
      raise result.ex
3734 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3735 
 
3956 chandransh 3736 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3737 
    """
3738 
    Marks the COD orders with given AWB nos. as having been processed.
3739 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3740 
 
3956 chandransh 3741 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3742 
    1. There is no order corresponding to an AWB number.
3743 
    2. The captured amount for a payment exceeds the total payment.
3744 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3745 
 
3746 
    Parameters:
3747 
     - collectedAmountMap
3748 
     - xferBy
3749 
     - xferTxnId
3750 
     - xferDate
3751 
    """
3752 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3753 
    return self.recv_reconcileCodCollection()
3754 
 
3755 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3756 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3757 
    args = reconcileCodCollection_args()
3758 
    args.collectedAmountMap = collectedAmountMap
3759 
    args.xferBy = xferBy
3760 
    args.xferTxnId = xferTxnId
3761 
    args.xferDate = xferDate
3762 
    args.write(self._oprot)
3763 
    self._oprot.writeMessageEnd()
3764 
    self._oprot.trans.flush()
3765 
 
3766 
  def recv_reconcileCodCollection(self, ):
3767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3768 
    if mtype == TMessageType.EXCEPTION:
3769 
      x = TApplicationException()
3770 
      x.read(self._iprot)
3771 
      self._iprot.readMessageEnd()
3772 
      raise x
3773 
    result = reconcileCodCollection_result()
3774 
    result.read(self._iprot)
3775 
    self._iprot.readMessageEnd()
3776 
    if result.success is not None:
3777 
      return result.success
3778 
    if result.ex is not None:
3779 
      raise result.ex
3780 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3781 
 
4008 mandeep.dh 3782 
  def getTransactionsRequiringExtraProcessing(self, category):
3783 
    """
4065 mandeep.dh 3784 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3785 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3786 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3787 
 
4008 mandeep.dh 3788 
    Parameters:
3789 
     - category
3790 
    """
3791 
    self.send_getTransactionsRequiringExtraProcessing(category)
3792 
    return self.recv_getTransactionsRequiringExtraProcessing()
3793 
 
3794 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3795 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3796 
    args = getTransactionsRequiringExtraProcessing_args()
3797 
    args.category = category
3798 
    args.write(self._oprot)
3799 
    self._oprot.writeMessageEnd()
3800 
    self._oprot.trans.flush()
3801 
 
3802 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3803 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3804 
    if mtype == TMessageType.EXCEPTION:
3805 
      x = TApplicationException()
3806 
      x.read(self._iprot)
3807 
      self._iprot.readMessageEnd()
3808 
      raise x
3809 
    result = getTransactionsRequiringExtraProcessing_result()
3810 
    result.read(self._iprot)
3811 
    self._iprot.readMessageEnd()
3812 
    if result.success is not None:
3813 
      return result.success
3814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3815 
 
3816 
  def markTransactionAsProcessed(self, transactionId, category):
3817 
    """
3818 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3819 
    It essentially deletes the transaction id record for a particular
3820 
    processing type category (if present) from DB.
3821 
    This is currently used by CRM application.
4008 mandeep.dh 3822 
 
3823 
    Parameters:
3824 
     - transactionId
3825 
     - category
3826 
    """
3827 
    self.send_markTransactionAsProcessed(transactionId, category)
3828 
    self.recv_markTransactionAsProcessed()
3829 
 
3830 
  def send_markTransactionAsProcessed(self, transactionId, category):
3831 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3832 
    args = markTransactionAsProcessed_args()
3833 
    args.transactionId = transactionId
3834 
    args.category = category
3835 
    args.write(self._oprot)
3836 
    self._oprot.writeMessageEnd()
3837 
    self._oprot.trans.flush()
3838 
 
3839 
  def recv_markTransactionAsProcessed(self, ):
3840 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3841 
    if mtype == TMessageType.EXCEPTION:
3842 
      x = TApplicationException()
3843 
      x.read(self._iprot)
3844 
      self._iprot.readMessageEnd()
3845 
      raise x
3846 
    result = markTransactionAsProcessed_result()
3847 
    result.read(self._iprot)
3848 
    self._iprot.readMessageEnd()
3849 
    return
3850 
 
4018 chandransh 3851 
  def getItemWiseRiskyOrdersCount(self, ):
3852 
    """
3853 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3854 
    is defined as one whose shipping date is about to expire.
3855 
    """
3856 
    self.send_getItemWiseRiskyOrdersCount()
3857 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3858 
 
4018 chandransh 3859 
  def send_getItemWiseRiskyOrdersCount(self, ):
3860 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3861 
    args = getItemWiseRiskyOrdersCount_args()
3862 
    args.write(self._oprot)
3863 
    self._oprot.writeMessageEnd()
3864 
    self._oprot.trans.flush()
3865 
 
3866 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3867 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3868 
    if mtype == TMessageType.EXCEPTION:
3869 
      x = TApplicationException()
3870 
      x.read(self._iprot)
3871 
      self._iprot.readMessageEnd()
3872 
      raise x
3873 
    result = getItemWiseRiskyOrdersCount_result()
3874 
    result.read(self._iprot)
3875 
    self._iprot.readMessageEnd()
3876 
    if result.success is not None:
3877 
      return result.success
3878 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3879 
 
4295 varun.gupt 3880 
  def getOrdersForItemIds(self, itemIds):
3881 
    """
3882 
    Returns a list of all orders which have items with given id
3883 
 
3884 
    Parameters:
3885 
     - itemIds
3886 
    """
3887 
    self.send_getOrdersForItemIds(itemIds)
3888 
    return self.recv_getOrdersForItemIds()
3889 
 
3890 
  def send_getOrdersForItemIds(self, itemIds):
3891 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3892 
    args = getOrdersForItemIds_args()
3893 
    args.itemIds = itemIds
3894 
    args.write(self._oprot)
3895 
    self._oprot.writeMessageEnd()
3896 
    self._oprot.trans.flush()
3897 
 
3898 
  def recv_getOrdersForItemIds(self, ):
3899 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3900 
    if mtype == TMessageType.EXCEPTION:
3901 
      x = TApplicationException()
3902 
      x.read(self._iprot)
3903 
      self._iprot.readMessageEnd()
3904 
      raise x
3905 
    result = getOrdersForItemIds_result()
3906 
    result.read(self._iprot)
3907 
    self._iprot.readMessageEnd()
3908 
    if result.success is not None:
3909 
      return result.success
3910 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3911 
 
4247 rajveer 3912 
  def markOrderCancellationRequestReceived(self, orderId):
3913 
    """
3914 
    Mark order as cancellation request received. If customer sends request of cancellation of
3915 
    a particular order, this method will be called. It will just change status of the order
3916 
    depending on its current status. It also records the previous status, so that we can move
3917 
    back to that status if cancellation request is denied.
4018 chandransh 3918 
 
4247 rajveer 3919 
    Parameters:
3920 
     - orderId
3921 
    """
3922 
    self.send_markOrderCancellationRequestReceived(orderId)
3923 
    self.recv_markOrderCancellationRequestReceived()
3924 
 
3925 
  def send_markOrderCancellationRequestReceived(self, orderId):
3926 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3927 
    args = markOrderCancellationRequestReceived_args()
3928 
    args.orderId = orderId
3929 
    args.write(self._oprot)
3930 
    self._oprot.writeMessageEnd()
3931 
    self._oprot.trans.flush()
3932 
 
3933 
  def recv_markOrderCancellationRequestReceived(self, ):
3934 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3935 
    if mtype == TMessageType.EXCEPTION:
3936 
      x = TApplicationException()
3937 
      x.read(self._iprot)
3938 
      self._iprot.readMessageEnd()
3939 
      raise x
3940 
    result = markOrderCancellationRequestReceived_result()
3941 
    result.read(self._iprot)
3942 
    self._iprot.readMessageEnd()
3943 
    if result.ex is not None:
3944 
      raise result.ex
3945 
    return
3946 
 
3947 
  def markOrderCancellationRequestConfirmed(self, orderId):
3948 
    """
3949 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3950 
    cancellation request confirmed. After this OM will be able to cancel the order.
3951 
 
3952 
    Parameters:
3953 
     - orderId
3954 
    """
3955 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3956 
    self.recv_markOrderCancellationRequestConfirmed()
3957 
 
3958 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3959 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3960 
    args = markOrderCancellationRequestConfirmed_args()
3961 
    args.orderId = orderId
3962 
    args.write(self._oprot)
3963 
    self._oprot.writeMessageEnd()
3964 
    self._oprot.trans.flush()
3965 
 
3966 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3968 
    if mtype == TMessageType.EXCEPTION:
3969 
      x = TApplicationException()
3970 
      x.read(self._iprot)
3971 
      self._iprot.readMessageEnd()
3972 
      raise x
3973 
    result = markOrderCancellationRequestConfirmed_result()
3974 
    result.read(self._iprot)
3975 
    self._iprot.readMessageEnd()
3976 
    if result.ex is not None:
3977 
      raise result.ex
3978 
    return
3979 
 
3980 
  def markOrderCancellationRequestDenied(self, orderId):
3981 
    """
3982 
    If we decide to not to cancel order, we will move the order ro previous status.
3983 
 
3984 
    Parameters:
3985 
     - orderId
3986 
    """
3987 
    self.send_markOrderCancellationRequestDenied(orderId)
3988 
    self.recv_markOrderCancellationRequestDenied()
3989 
 
3990 
  def send_markOrderCancellationRequestDenied(self, orderId):
3991 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3992 
    args = markOrderCancellationRequestDenied_args()
3993 
    args.orderId = orderId
3994 
    args.write(self._oprot)
3995 
    self._oprot.writeMessageEnd()
3996 
    self._oprot.trans.flush()
3997 
 
3998 
  def recv_markOrderCancellationRequestDenied(self, ):
3999 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4000 
    if mtype == TMessageType.EXCEPTION:
4001 
      x = TApplicationException()
4002 
      x.read(self._iprot)
4003 
      self._iprot.readMessageEnd()
4004 
      raise x
4005 
    result = markOrderCancellationRequestDenied_result()
4006 
    result.read(self._iprot)
4007 
    self._iprot.readMessageEnd()
4008 
    if result.ex is not None:
4009 
      raise result.ex
4010 
    return
4011 
 
4258 rajveer 4012 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4013 
    """
4258 rajveer 4014 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4015 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4016 
 
4017 
    Parameters:
4258 rajveer 4018 
     - transactionId
4247 rajveer 4019 
    """
4258 rajveer 4020 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4021 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4022 
 
4258 rajveer 4023 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4024 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4025 
    args = markTransactionAsPaymentFlagRemoved_args()
4026 
    args.transactionId = transactionId
4247 rajveer 4027 
    args.write(self._oprot)
4028 
    self._oprot.writeMessageEnd()
4029 
    self._oprot.trans.flush()
4030 
 
4258 rajveer 4031 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4033 
    if mtype == TMessageType.EXCEPTION:
4034 
      x = TApplicationException()
4035 
      x.read(self._iprot)
4036 
      self._iprot.readMessageEnd()
4037 
      raise x
4258 rajveer 4038 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4039 
    result.read(self._iprot)
4040 
    self._iprot.readMessageEnd()
4041 
    if result.ex is not None:
4042 
      raise result.ex
4043 
    return
4044 
 
4259 anupam.sin 4045 
  def refundTransaction(self, transactionId, refundedBy, reason):
4046 
    """
4047 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4048 
    need to be cancelled
4247 rajveer 4049 
 
4259 anupam.sin 4050 
    Parameters:
4051 
     - transactionId
4052 
     - refundedBy
4053 
     - reason
4054 
    """
4055 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4056 
    self.recv_refundTransaction()
4057 
 
4058 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4059 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4060 
    args = refundTransaction_args()
4061 
    args.transactionId = transactionId
4062 
    args.refundedBy = refundedBy
4063 
    args.reason = reason
4064 
    args.write(self._oprot)
4065 
    self._oprot.writeMessageEnd()
4066 
    self._oprot.trans.flush()
4067 
 
4068 
  def recv_refundTransaction(self, ):
4069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4070 
    if mtype == TMessageType.EXCEPTION:
4071 
      x = TApplicationException()
4072 
      x.read(self._iprot)
4073 
      self._iprot.readMessageEnd()
4074 
      raise x
4075 
    result = refundTransaction_result()
4076 
    result.read(self._iprot)
4077 
    self._iprot.readMessageEnd()
4078 
    if result.ex is not None:
4079 
      raise result.ex
4080 
    return
4081 
 
4324 mandeep.dh 4082 
  def updateShipmentAddress(self, orderId, addressId):
4083 
    """
4084 
    Updates shipment address of an order. Delivery and shipping date estimates
4085 
    etc. are also updated here.
4086 
 
4087 
    Throws TransactionServiceException in case address change is not
4088 
    possible due to certain reasons such as new pincode in address is
4089 
    not serviceable etc.
4090 
 
4091 
    Parameters:
4092 
     - orderId
4093 
     - addressId
4094 
    """
4095 
    self.send_updateShipmentAddress(orderId, addressId)
4096 
    self.recv_updateShipmentAddress()
4097 
 
4098 
  def send_updateShipmentAddress(self, orderId, addressId):
4099 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4100 
    args = updateShipmentAddress_args()
4101 
    args.orderId = orderId
4102 
    args.addressId = addressId
4103 
    args.write(self._oprot)
4104 
    self._oprot.writeMessageEnd()
4105 
    self._oprot.trans.flush()
4106 
 
4107 
  def recv_updateShipmentAddress(self, ):
4108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4109 
    if mtype == TMessageType.EXCEPTION:
4110 
      x = TApplicationException()
4111 
      x.read(self._iprot)
4112 
      self._iprot.readMessageEnd()
4113 
      raise x
4114 
    result = updateShipmentAddress_result()
4115 
    result.read(self._iprot)
4116 
    self._iprot.readMessageEnd()
4117 
    if result.ex is not None:
4118 
      raise result.ex
4119 
    return
4120 
 
4285 rajveer 4121 
  def acceptOrdersForItemId(self, itemId, inventory):
4122 
    """
4123 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4124 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4125 
 
4285 rajveer 4126 
    Parameters:
4127 
     - itemId
4128 
     - inventory
4129 
    """
4130 
    self.send_acceptOrdersForItemId(itemId, inventory)
4131 
    return self.recv_acceptOrdersForItemId()
4132 
 
4133 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4134 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4135 
    args = acceptOrdersForItemId_args()
4136 
    args.itemId = itemId
4137 
    args.inventory = inventory
4138 
    args.write(self._oprot)
4139 
    self._oprot.writeMessageEnd()
4140 
    self._oprot.trans.flush()
4141 
 
4142 
  def recv_acceptOrdersForItemId(self, ):
4143 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4144 
    if mtype == TMessageType.EXCEPTION:
4145 
      x = TApplicationException()
4146 
      x.read(self._iprot)
4147 
      self._iprot.readMessageEnd()
4148 
      raise x
4149 
    result = acceptOrdersForItemId_result()
4150 
    result.read(self._iprot)
4151 
    self._iprot.readMessageEnd()
4152 
    if result.success is not None:
4153 
      return result.success
4154 
    if result.ex is not None:
4155 
      raise result.ex
4156 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4157 
 
4369 rajveer 4158 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4159 
    """
4160 
    Parameters:
4161 
     - vendorId
4162 
     - itemId
4163 
     - quantity
4164 
     - estimate
4369 rajveer 4165 
     - isReminder
4303 rajveer 4166 
    """
4369 rajveer 4167 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4168 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4169 
 
4369 rajveer 4170 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4171 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4172 
    args = markOrdersAsPORaised_args()
4173 
    args.vendorId = vendorId
4174 
    args.itemId = itemId
4175 
    args.quantity = quantity
4176 
    args.estimate = estimate
4369 rajveer 4177 
    args.isReminder = isReminder
4303 rajveer 4178 
    args.write(self._oprot)
4179 
    self._oprot.writeMessageEnd()
4180 
    self._oprot.trans.flush()
4181 
 
4182 
  def recv_markOrdersAsPORaised(self, ):
4183 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4184 
    if mtype == TMessageType.EXCEPTION:
4185 
      x = TApplicationException()
4186 
      x.read(self._iprot)
4187 
      self._iprot.readMessageEnd()
4188 
      raise x
4189 
    result = markOrdersAsPORaised_result()
4190 
    result.read(self._iprot)
4191 
    self._iprot.readMessageEnd()
4192 
    if result.ex is not None:
4193 
      raise result.ex
4194 
    return
4195 
 
4369 rajveer 4196 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4197 
    """
4198 
    Parameters:
4199 
     - vendorId
4200 
     - itemId
4201 
     - quantity
4202 
     - estimate
4369 rajveer 4203 
     - isReminder
4303 rajveer 4204 
    """
4369 rajveer 4205 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4206 
    self.recv_markOrdersAsReversalInitiated()
4207 
 
4369 rajveer 4208 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4209 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4210 
    args = markOrdersAsReversalInitiated_args()
4211 
    args.vendorId = vendorId
4212 
    args.itemId = itemId
4213 
    args.quantity = quantity
4214 
    args.estimate = estimate
4369 rajveer 4215 
    args.isReminder = isReminder
4303 rajveer 4216 
    args.write(self._oprot)
4217 
    self._oprot.writeMessageEnd()
4218 
    self._oprot.trans.flush()
4219 
 
4220 
  def recv_markOrdersAsReversalInitiated(self, ):
4221 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4222 
    if mtype == TMessageType.EXCEPTION:
4223 
      x = TApplicationException()
4224 
      x.read(self._iprot)
4225 
      self._iprot.readMessageEnd()
4226 
      raise x
4227 
    result = markOrdersAsReversalInitiated_result()
4228 
    result.read(self._iprot)
4229 
    self._iprot.readMessageEnd()
4230 
    if result.ex is not None:
4231 
      raise result.ex
4232 
    return
4233 
 
4369 rajveer 4234 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4235 
    """
4236 
    Parameters:
4237 
     - vendorId
4238 
     - itemId
4239 
     - quantity
4240 
     - estimate
4369 rajveer 4241 
     - isReminder
4303 rajveer 4242 
    """
4369 rajveer 4243 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4244 
    self.recv_markOrdersAsNotAvailabke()
4245 
 
4369 rajveer 4246 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4247 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4248 
    args = markOrdersAsNotAvailabke_args()
4249 
    args.vendorId = vendorId
4250 
    args.itemId = itemId
4251 
    args.quantity = quantity
4252 
    args.estimate = estimate
4369 rajveer 4253 
    args.isReminder = isReminder
4303 rajveer 4254 
    args.write(self._oprot)
4255 
    self._oprot.writeMessageEnd()
4256 
    self._oprot.trans.flush()
4257 
 
4258 
  def recv_markOrdersAsNotAvailabke(self, ):
4259 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4260 
    if mtype == TMessageType.EXCEPTION:
4261 
      x = TApplicationException()
4262 
      x.read(self._iprot)
4263 
      self._iprot.readMessageEnd()
4264 
      raise x
4265 
    result = markOrdersAsNotAvailabke_result()
4266 
    result.read(self._iprot)
4267 
    self._iprot.readMessageEnd()
4268 
    if result.ex is not None:
4269 
      raise result.ex
4270 
    return
4271 
 
4369 rajveer 4272 
  def markOrdersAsTimeout(self, vendorId):
4273 
    """
4274 
    Parameters:
4275 
     - vendorId
4276 
    """
4277 
    self.send_markOrdersAsTimeout(vendorId)
4278 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4279 
 
4369 rajveer 4280 
  def send_markOrdersAsTimeout(self, vendorId):
4281 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4282 
    args = markOrdersAsTimeout_args()
4283 
    args.vendorId = vendorId
4284 
    args.write(self._oprot)
4285 
    self._oprot.writeMessageEnd()
4286 
    self._oprot.trans.flush()
4287 
 
4288 
  def recv_markOrdersAsTimeout(self, ):
4289 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4290 
    if mtype == TMessageType.EXCEPTION:
4291 
      x = TApplicationException()
4292 
      x.read(self._iprot)
4293 
      self._iprot.readMessageEnd()
4294 
      raise x
4295 
    result = markOrdersAsTimeout_result()
4296 
    result.read(self._iprot)
4297 
    self._iprot.readMessageEnd()
4298 
    if result.success is not None:
4299 
      return result.success
4300 
    if result.ex is not None:
4301 
      raise result.ex
4302 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4303 
 
4662 rajveer 4304 
  def markOrderAsLostInTransit(self, orderId):
4305 
    """
4306 
    Mark order as LOST_IN_TRANSIT
4307 
 
4308 
    Parameters:
4309 
     - orderId
4310 
    """
4311 
    self.send_markOrderAsLostInTransit(orderId)
4312 
    return self.recv_markOrderAsLostInTransit()
4313 
 
4314 
  def send_markOrderAsLostInTransit(self, orderId):
4315 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4316 
    args = markOrderAsLostInTransit_args()
4317 
    args.orderId = orderId
4318 
    args.write(self._oprot)
4319 
    self._oprot.writeMessageEnd()
4320 
    self._oprot.trans.flush()
4321 
 
4322 
  def recv_markOrderAsLostInTransit(self, ):
4323 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4324 
    if mtype == TMessageType.EXCEPTION:
4325 
      x = TApplicationException()
4326 
      x.read(self._iprot)
4327 
      self._iprot.readMessageEnd()
4328 
      raise x
4329 
    result = markOrderAsLostInTransit_result()
4330 
    result.read(self._iprot)
4331 
    self._iprot.readMessageEnd()
4332 
    if result.success is not None:
4333 
      return result.success
4334 
    if result.ex is not None:
4335 
      raise result.ex
4336 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4337 
 
4386 anupam.sin 4338 
  def getOrderForAwb(self, awb):
4339 
    """
4340 
    Returns the order corresponding to an AWB number
4369 rajveer 4341 
 
4386 anupam.sin 4342 
    Parameters:
4343 
     - awb
4344 
    """
4345 
    self.send_getOrderForAwb(awb)
4346 
    return self.recv_getOrderForAwb()
4347 
 
4348 
  def send_getOrderForAwb(self, awb):
4349 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4350 
    args = getOrderForAwb_args()
4351 
    args.awb = awb
4352 
    args.write(self._oprot)
4353 
    self._oprot.writeMessageEnd()
4354 
    self._oprot.trans.flush()
4355 
 
4356 
  def recv_getOrderForAwb(self, ):
4357 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4358 
    if mtype == TMessageType.EXCEPTION:
4359 
      x = TApplicationException()
4360 
      x.read(self._iprot)
4361 
      self._iprot.readMessageEnd()
4362 
      raise x
4363 
    result = getOrderForAwb_result()
4364 
    result.read(self._iprot)
4365 
    self._iprot.readMessageEnd()
4366 
    if result.success is not None:
4367 
      return result.success
4368 
    if result.ex is not None:
4369 
      raise result.ex
4370 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4371 
 
4910 phani.kuma 4372 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4373 
    """
4910 phani.kuma 4374 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4375 
 
4506 phani.kuma 4376 
    Parameters:
4377 
     - logistics_provider_id
4910 phani.kuma 4378 
     - order_status_list
4506 phani.kuma 4379 
    """
4910 phani.kuma 4380 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4381 
    return self.recv_getOrdersForProviderForStatus()
4382 
 
4910 phani.kuma 4383 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4384 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4385 
    args = getOrdersForProviderForStatus_args()
4386 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4387 
    args.order_status_list = order_status_list
4506 phani.kuma 4388 
    args.write(self._oprot)
4389 
    self._oprot.writeMessageEnd()
4390 
    self._oprot.trans.flush()
4391 
 
4392 
  def recv_getOrdersForProviderForStatus(self, ):
4393 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4394 
    if mtype == TMessageType.EXCEPTION:
4395 
      x = TApplicationException()
4396 
      x.read(self._iprot)
4397 
      self._iprot.readMessageEnd()
4398 
      raise x
4399 
    result = getOrdersForProviderForStatus_result()
4400 
    result.read(self._iprot)
4401 
    self._iprot.readMessageEnd()
4402 
    if result.success is not None:
4403 
      return result.success
4404 
    if result.ex is not None:
4405 
      raise result.ex
4406 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4407 
 
4600 varun.gupt 4408 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4409 
    """
4410 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4411 
 
4600 varun.gupt 4412 
    Parameters:
4413 
     - vendorId
4414 
     - billingDateFrom
4415 
     - billingDateTo
4416 
    """
4417 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4418 
    return self.recv_getBilledOrdersForVendor()
4419 
 
4420 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4421 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4422 
    args = getBilledOrdersForVendor_args()
4423 
    args.vendorId = vendorId
4424 
    args.billingDateFrom = billingDateFrom
4425 
    args.billingDateTo = billingDateTo
4426 
    args.write(self._oprot)
4427 
    self._oprot.writeMessageEnd()
4428 
    self._oprot.trans.flush()
4429 
 
4430 
  def recv_getBilledOrdersForVendor(self, ):
4431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4432 
    if mtype == TMessageType.EXCEPTION:
4433 
      x = TApplicationException()
4434 
      x.read(self._iprot)
4435 
      self._iprot.readMessageEnd()
4436 
      raise x
4437 
    result = getBilledOrdersForVendor_result()
4438 
    result.read(self._iprot)
4439 
    self._iprot.readMessageEnd()
4440 
    if result.success is not None:
4441 
      return result.success
4442 
    if result.ex is not None:
4443 
      raise result.ex
4444 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4445 
 
4607 rajveer 4446 
  def getSlippedSippingDateOrders(self, ):
4447 
    self.send_getSlippedSippingDateOrders()
4448 
    return self.recv_getSlippedSippingDateOrders()
4449 
 
4450 
  def send_getSlippedSippingDateOrders(self, ):
4451 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4452 
    args = getSlippedSippingDateOrders_args()
4453 
    args.write(self._oprot)
4454 
    self._oprot.writeMessageEnd()
4455 
    self._oprot.trans.flush()
4456 
 
4457 
  def recv_getSlippedSippingDateOrders(self, ):
4458 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4459 
    if mtype == TMessageType.EXCEPTION:
4460 
      x = TApplicationException()
4461 
      x.read(self._iprot)
4462 
      self._iprot.readMessageEnd()
4463 
      raise x
4464 
    result = getSlippedSippingDateOrders_result()
4465 
    result.read(self._iprot)
4466 
    self._iprot.readMessageEnd()
4467 
    if result.success is not None:
4468 
      return result.success
4469 
    if result.ex is not None:
4470 
      raise result.ex
4471 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4472 
 
4709 rajveer 4473 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4474 
    """
4475 
    Parameters:
4476 
     - cancelDateFrom
4477 
     - cancelDateTo
4478 
    """
4479 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4480 
    return self.recv_getCancelledOrders()
4481 
 
4482 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4483 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4484 
    args = getCancelledOrders_args()
4485 
    args.cancelDateFrom = cancelDateFrom
4486 
    args.cancelDateTo = cancelDateTo
4487 
    args.write(self._oprot)
4488 
    self._oprot.writeMessageEnd()
4489 
    self._oprot.trans.flush()
4490 
 
4491 
  def recv_getCancelledOrders(self, ):
4492 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4493 
    if mtype == TMessageType.EXCEPTION:
4494 
      x = TApplicationException()
4495 
      x.read(self._iprot)
4496 
      self._iprot.readMessageEnd()
4497 
      raise x
4498 
    result = getCancelledOrders_result()
4499 
    result.read(self._iprot)
4500 
    self._iprot.readMessageEnd()
4501 
    if result.success is not None:
4502 
      return result.success
4503 
    if result.ex is not None:
4504 
      raise result.ex
4505 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4506 
 
4600 varun.gupt 4507 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4508 
    """
4509 
    Parameters:
4510 
     - mapAWBAndAmount
4511 
    """
4512 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4513 
    self.recv_saveBluedartSettlements()
4514 
 
4515 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4516 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4517 
    args = saveBluedartSettlements_args()
4518 
    args.mapAWBAndAmount = mapAWBAndAmount
4519 
    args.write(self._oprot)
4520 
    self._oprot.writeMessageEnd()
4521 
    self._oprot.trans.flush()
4522 
 
4523 
  def recv_saveBluedartSettlements(self, ):
4524 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4525 
    if mtype == TMessageType.EXCEPTION:
4526 
      x = TApplicationException()
4527 
      x.read(self._iprot)
4528 
      self._iprot.readMessageEnd()
4529 
      raise x
4530 
    result = saveBluedartSettlements_result()
4531 
    result.read(self._iprot)
4532 
    self._iprot.readMessageEnd()
4533 
    if result.ex is not None:
4534 
      raise result.ex
4535 
    return
4536 
 
4905 varun.gupt 4537 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4538 
    """
4539 
    Parameters:
4540 
     - settlementDate
4541 
     - paymentGatewayId
4905 varun.gupt 4542 
     - referenceId
4600 varun.gupt 4543 
     - serviceTax
4544 
     - otherCharges
4545 
     - netCollection
4546 
    """
4905 varun.gupt 4547 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4548 
    self.recv_savePaymentSettlements()
4549 
 
4905 varun.gupt 4550 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4551 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4552 
    args = savePaymentSettlements_args()
4553 
    args.settlementDate = settlementDate
4554 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4555 
    args.referenceId = referenceId
4600 varun.gupt 4556 
    args.serviceTax = serviceTax
4557 
    args.otherCharges = otherCharges
4558 
    args.netCollection = netCollection
4559 
    args.write(self._oprot)
4560 
    self._oprot.writeMessageEnd()
4561 
    self._oprot.trans.flush()
4562 
 
4563 
  def recv_savePaymentSettlements(self, ):
4564 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4565 
    if mtype == TMessageType.EXCEPTION:
4566 
      x = TApplicationException()
4567 
      x.read(self._iprot)
4568 
      self._iprot.readMessageEnd()
4569 
      raise x
4570 
    result = savePaymentSettlements_result()
4571 
    result.read(self._iprot)
4572 
    self._iprot.readMessageEnd()
4573 
    if result.ex is not None:
4574 
      raise result.ex
4575 
    return
4576 
 
4577 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4578 
    """
4579 
    Parameters:
4580 
     - settlementId
4581 
     - settlementDate
4582 
     - transactionDateFrom
4583 
     - transactionDateTo
4584 
     - amount
4585 
    """
4586 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4587 
    self.recv_saveEBSSettlementSummary()
4588 
 
4589 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4590 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4591 
    args = saveEBSSettlementSummary_args()
4592 
    args.settlementId = settlementId
4593 
    args.settlementDate = settlementDate
4594 
    args.transactionDateFrom = transactionDateFrom
4595 
    args.transactionDateTo = transactionDateTo
4596 
    args.amount = amount
4597 
    args.write(self._oprot)
4598 
    self._oprot.writeMessageEnd()
4599 
    self._oprot.trans.flush()
4600 
 
4601 
  def recv_saveEBSSettlementSummary(self, ):
4602 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4603 
    if mtype == TMessageType.EXCEPTION:
4604 
      x = TApplicationException()
4605 
      x.read(self._iprot)
4606 
      self._iprot.readMessageEnd()
4607 
      raise x
4608 
    result = saveEBSSettlementSummary_result()
4609 
    result.read(self._iprot)
4610 
    self._iprot.readMessageEnd()
4611 
    if result.ex is not None:
4612 
      raise result.ex
4613 
    return
4614 
 
4615 
  def getSettlementForPaymentId(self, paymentId):
4616 
    """
4617 
    Parameters:
4618 
     - paymentId
4619 
    """
4620 
    self.send_getSettlementForPaymentId(paymentId)
4621 
    return self.recv_getSettlementForPaymentId()
4622 
 
4623 
  def send_getSettlementForPaymentId(self, paymentId):
4624 
    self._oprot.writeMessageBegin('getSettlementForPaymentId', TMessageType.CALL, self._seqid)
4625 
    args = getSettlementForPaymentId_args()
4626 
    args.paymentId = paymentId
4627 
    args.write(self._oprot)
4628 
    self._oprot.writeMessageEnd()
4629 
    self._oprot.trans.flush()
4630 
 
4631 
  def recv_getSettlementForPaymentId(self, ):
4632 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4633 
    if mtype == TMessageType.EXCEPTION:
4634 
      x = TApplicationException()
4635 
      x.read(self._iprot)
4636 
      self._iprot.readMessageEnd()
4637 
      raise x
4638 
    result = getSettlementForPaymentId_result()
4639 
    result.read(self._iprot)
4640 
    self._iprot.readMessageEnd()
4641 
    if result.success is not None:
4642 
      return result.success
4643 
    if result.ex is not None:
4644 
      raise result.ex
4645 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPaymentId failed: unknown result");
4646 
 
4647 
  def getEBSSettlementSummaries(self, ):
4648 
    self.send_getEBSSettlementSummaries()
4649 
    return self.recv_getEBSSettlementSummaries()
4650 
 
4651 
  def send_getEBSSettlementSummaries(self, ):
4652 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4653 
    args = getEBSSettlementSummaries_args()
4654 
    args.write(self._oprot)
4655 
    self._oprot.writeMessageEnd()
4656 
    self._oprot.trans.flush()
4657 
 
4658 
  def recv_getEBSSettlementSummaries(self, ):
4659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4660 
    if mtype == TMessageType.EXCEPTION:
4661 
      x = TApplicationException()
4662 
      x.read(self._iprot)
4663 
      self._iprot.readMessageEnd()
4664 
      raise x
4665 
    result = getEBSSettlementSummaries_result()
4666 
    result.read(self._iprot)
4667 
    self._iprot.readMessageEnd()
4668 
    if result.success is not None:
4669 
      return result.success
4670 
    if result.ex is not None:
4671 
      raise result.ex
4672 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4673 
 
4674 
  def markEBSSettlementUploaded(self, settlementId):
4675 
    """
4676 
    Parameters:
4677 
     - settlementId
4678 
    """
4679 
    self.send_markEBSSettlementUploaded(settlementId)
4680 
    self.recv_markEBSSettlementUploaded()
4681 
 
4682 
  def send_markEBSSettlementUploaded(self, settlementId):
4683 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4684 
    args = markEBSSettlementUploaded_args()
4685 
    args.settlementId = settlementId
4686 
    args.write(self._oprot)
4687 
    self._oprot.writeMessageEnd()
4688 
    self._oprot.trans.flush()
4689 
 
4690 
  def recv_markEBSSettlementUploaded(self, ):
4691 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4692 
    if mtype == TMessageType.EXCEPTION:
4693 
      x = TApplicationException()
4694 
      x.read(self._iprot)
4695 
      self._iprot.readMessageEnd()
4696 
      raise x
4697 
    result = markEBSSettlementUploaded_result()
4698 
    result.read(self._iprot)
4699 
    self._iprot.readMessageEnd()
4700 
    if result.ex is not None:
4701 
      raise result.ex
4702 
    return
4703 
 
4704 
  def getEBSSettlementDate(self, settlementId):
4705 
    """
4706 
    Parameters:
4707 
     - settlementId
4708 
    """
4709 
    self.send_getEBSSettlementDate(settlementId)
4710 
    return self.recv_getEBSSettlementDate()
4711 
 
4712 
  def send_getEBSSettlementDate(self, settlementId):
4713 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4714 
    args = getEBSSettlementDate_args()
4715 
    args.settlementId = settlementId
4716 
    args.write(self._oprot)
4717 
    self._oprot.writeMessageEnd()
4718 
    self._oprot.trans.flush()
4719 
 
4720 
  def recv_getEBSSettlementDate(self, ):
4721 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4722 
    if mtype == TMessageType.EXCEPTION:
4723 
      x = TApplicationException()
4724 
      x.read(self._iprot)
4725 
      self._iprot.readMessageEnd()
4726 
      raise x
4727 
    result = getEBSSettlementDate_result()
4728 
    result.read(self._iprot)
4729 
    self._iprot.readMessageEnd()
4730 
    if result.success is not None:
4731 
      return result.success
4732 
    if result.ex is not None:
4733 
      raise result.ex
4734 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4735 
 
4715 varun.gupt 4736 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4737 
    """
4738 
    Parameters:
4739 
     - settlementDateFrom
4740 
     - settlementDateTo
4741 
     - isRefund
4742 
    """
4743 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4744 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4745 
 
4715 varun.gupt 4746 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4747 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4748 
    args = getSettlementsByDate_args()
4749 
    args.settlementDateFrom = settlementDateFrom
4750 
    args.settlementDateTo = settlementDateTo
4751 
    args.isRefund = isRefund
4752 
    args.write(self._oprot)
4753 
    self._oprot.writeMessageEnd()
4754 
    self._oprot.trans.flush()
4755 
 
4756 
  def recv_getSettlementsByDate(self, ):
4757 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4758 
    if mtype == TMessageType.EXCEPTION:
4759 
      x = TApplicationException()
4760 
      x.read(self._iprot)
4761 
      self._iprot.readMessageEnd()
4762 
      raise x
4763 
    result = getSettlementsByDate_result()
4764 
    result.read(self._iprot)
4765 
    self._iprot.readMessageEnd()
4766 
    if result.success is not None:
4767 
      return result.success
4768 
    if result.ex is not None:
4769 
      raise result.ex
4770 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4771 
 
4772 
  def getReshippedOrderIds(self, orderIds):
4773 
    """
4774 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4775 
 
4776 
    Parameters:
4777 
     - orderIds
4778 
    """
4779 
    self.send_getReshippedOrderIds(orderIds)
4780 
    return self.recv_getReshippedOrderIds()
4781 
 
4782 
  def send_getReshippedOrderIds(self, orderIds):
4783 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4784 
    args = getReshippedOrderIds_args()
4785 
    args.orderIds = orderIds
4786 
    args.write(self._oprot)
4787 
    self._oprot.writeMessageEnd()
4788 
    self._oprot.trans.flush()
4789 
 
4790 
  def recv_getReshippedOrderIds(self, ):
4791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4792 
    if mtype == TMessageType.EXCEPTION:
4793 
      x = TApplicationException()
4794 
      x.read(self._iprot)
4795 
      self._iprot.readMessageEnd()
4796 
      raise x
4797 
    result = getReshippedOrderIds_result()
4798 
    result.read(self._iprot)
4799 
    self._iprot.readMessageEnd()
4800 
    if result.success is not None:
4801 
      return result.success
4802 
    if result.ex is not None:
4803 
      raise result.ex
4804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4805 
 
4757 mandeep.dh 4806 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4807 
    """
4808 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
4809 
    the quantities for which the PO is raised.
4715 varun.gupt 4810 
 
4757 mandeep.dh 4811 
    Parameters:
4812 
     - itemIdQuantityMap
4813 
     - purchaseOrderId
4814 
     - warehouseId
4815 
    """
4816 
    self.send_updateOrdersAsPORaised(itemIdQuantityMap, purchaseOrderId, warehouseId)
4817 
    self.recv_updateOrdersAsPORaised()
4818 
 
4819 
  def send_updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4820 
    self._oprot.writeMessageBegin('updateOrdersAsPORaised', TMessageType.CALL, self._seqid)
4821 
    args = updateOrdersAsPORaised_args()
4822 
    args.itemIdQuantityMap = itemIdQuantityMap
4823 
    args.purchaseOrderId = purchaseOrderId
4824 
    args.warehouseId = warehouseId
4825 
    args.write(self._oprot)
4826 
    self._oprot.writeMessageEnd()
4827 
    self._oprot.trans.flush()
4828 
 
4829 
  def recv_updateOrdersAsPORaised(self, ):
4830 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4831 
    if mtype == TMessageType.EXCEPTION:
4832 
      x = TApplicationException()
4833 
      x.read(self._iprot)
4834 
      self._iprot.readMessageEnd()
4835 
      raise x
4836 
    result = updateOrdersAsPORaised_result()
4837 
    result.read(self._iprot)
4838 
    self._iprot.readMessageEnd()
4839 
    if result.ex is not None:
4840 
      raise result.ex
4841 
    return
4842 
 
4875 varun.gupt 4843 
  def getOrdersWhereVendorNotPaid(self, vendorId):
4844 
    """
4845 
    Parameters:
4846 
     - vendorId
4847 
    """
4848 
    self.send_getOrdersWhereVendorNotPaid(vendorId)
4849 
    return self.recv_getOrdersWhereVendorNotPaid()
4757 mandeep.dh 4850 
 
4875 varun.gupt 4851 
  def send_getOrdersWhereVendorNotPaid(self, vendorId):
4852 
    self._oprot.writeMessageBegin('getOrdersWhereVendorNotPaid', TMessageType.CALL, self._seqid)
4853 
    args = getOrdersWhereVendorNotPaid_args()
4854 
    args.vendorId = vendorId
4855 
    args.write(self._oprot)
4856 
    self._oprot.writeMessageEnd()
4857 
    self._oprot.trans.flush()
4858 
 
4859 
  def recv_getOrdersWhereVendorNotPaid(self, ):
4860 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4861 
    if mtype == TMessageType.EXCEPTION:
4862 
      x = TApplicationException()
4863 
      x.read(self._iprot)
4864 
      self._iprot.readMessageEnd()
4865 
      raise x
4866 
    result = getOrdersWhereVendorNotPaid_result()
4867 
    result.read(self._iprot)
4868 
    self._iprot.readMessageEnd()
4869 
    if result.success is not None:
4870 
      return result.success
4871 
    if result.ex is not None:
4872 
      raise result.ex
4873 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersWhereVendorNotPaid failed: unknown result");
4874 
 
5031 varun.gupt 4875 
  def getStatusDistributionOfOrders(self, startDate, endDate):
4876 
    """
4877 
    Parameters:
4878 
     - startDate
4879 
     - endDate
4880 
    """
4881 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
4882 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 4883 
 
5031 varun.gupt 4884 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
4885 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
4886 
    args = getStatusDistributionOfOrders_args()
4887 
    args.startDate = startDate
4888 
    args.endDate = endDate
4889 
    args.write(self._oprot)
4890 
    self._oprot.writeMessageEnd()
4891 
    self._oprot.trans.flush()
4892 
 
4893 
  def recv_getStatusDistributionOfOrders(self, ):
4894 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4895 
    if mtype == TMessageType.EXCEPTION:
4896 
      x = TApplicationException()
4897 
      x.read(self._iprot)
4898 
      self._iprot.readMessageEnd()
4899 
      raise x
4900 
    result = getStatusDistributionOfOrders_result()
4901 
    result.read(self._iprot)
4902 
    self._iprot.readMessageEnd()
4903 
    if result.success is not None:
4904 
      return result.success
4905 
    if result.ex is not None:
4906 
      raise result.ex
4907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
4908 
 
5067 varun.gupt 4909 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
4910 
    """
4911 
    Parameters:
4912 
     - status
4913 
     - startDatetime
4914 
     - endDatetime
4915 
    """
4916 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
4917 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 4918 
 
5067 varun.gupt 4919 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
4920 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
4921 
    args = getOrderIdsForStatus_args()
4922 
    args.status = status
4923 
    args.startDatetime = startDatetime
4924 
    args.endDatetime = endDatetime
4925 
    args.write(self._oprot)
4926 
    self._oprot.writeMessageEnd()
4927 
    self._oprot.trans.flush()
4928 
 
4929 
  def recv_getOrderIdsForStatus(self, ):
4930 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4931 
    if mtype == TMessageType.EXCEPTION:
4932 
      x = TApplicationException()
4933 
      x.read(self._iprot)
4934 
      self._iprot.readMessageEnd()
4935 
      raise x
4936 
    result = getOrderIdsForStatus_result()
4937 
    result.read(self._iprot)
4938 
    self._iprot.readMessageEnd()
4939 
    if result.success is not None:
4940 
      return result.success
4941 
    if result.ex is not None:
4942 
      raise result.ex
4943 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
4944 
 
5099 varun.gupt 4945 
  def updateOrderAsPaidToVendor(self, orderId):
4946 
    """
4947 
    Parameters:
4948 
     - orderId
4949 
    """
4950 
    self.send_updateOrderAsPaidToVendor(orderId)
4951 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 4952 
 
5099 varun.gupt 4953 
  def send_updateOrderAsPaidToVendor(self, orderId):
4954 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
4955 
    args = updateOrderAsPaidToVendor_args()
4956 
    args.orderId = orderId
4957 
    args.write(self._oprot)
4958 
    self._oprot.writeMessageEnd()
4959 
    self._oprot.trans.flush()
4960 
 
4961 
  def recv_updateOrderAsPaidToVendor(self, ):
4962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4963 
    if mtype == TMessageType.EXCEPTION:
4964 
      x = TApplicationException()
4965 
      x.read(self._iprot)
4966 
      self._iprot.readMessageEnd()
4967 
      raise x
4968 
    result = updateOrderAsPaidToVendor_result()
4969 
    result.read(self._iprot)
4970 
    self._iprot.readMessageEnd()
4971 
    if result.ex is not None:
4972 
      raise result.ex
4973 
    return
4974 
 
4975 
 
3376 rajveer 4976 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4977 
  def __init__(self, handler):
3376 rajveer 4978 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4979 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4980 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4981 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4982 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4983 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4984 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4985 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4986 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4987 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4988 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4989 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4990 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4991 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4992 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4993 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4994 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4995 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4996 
    self._processMap["createOrder"] = Processor.process_createOrder
4997 
    self._processMap["getOrder"] = Processor.process_getOrder
4998 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 4999 
    self._processMap["getOrderList"] = Processor.process_getOrderList
1528 ankur.sing 5000 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 5001 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 5002 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 5003 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 5004 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
5005 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
5006 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
5007 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 5008 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 5009 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 5010 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
5011 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
5012 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 5013 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 5014 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 5015 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 5016 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 5017 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 5018 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
5019 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 5020 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 5021 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
5022 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
5023 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
5024 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
5025 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 5026 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 5027 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 5028 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 5029 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 5030 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
5031 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 5032 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
5033 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 5034 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
5035 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 5036 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 5037 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 5038 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 5039 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 5040 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 5041 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 5042 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 5043 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
5044 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 5045 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 5046 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 5047 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 5048 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 5049 
    self._processMap["changeItem"] = Processor.process_changeItem
5050 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 5051 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 5052 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 5053 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
5054 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 5055 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 5056 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 5057 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
5058 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
5059 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 5060 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 5061 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 5062 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 5063 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 5064 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
5065 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
5066 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 5067 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 5068 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 5069 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 5070 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 5071 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 5072 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 5073 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 5074 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
5075 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
5076 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5077 
    self._processMap["getSettlementForPaymentId"] = Processor.process_getSettlementForPaymentId
5078 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
5079 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
5080 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 5081 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
5082 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
4757 mandeep.dh 5083 
    self._processMap["updateOrdersAsPORaised"] = Processor.process_updateOrdersAsPORaised
4875 varun.gupt 5084 
    self._processMap["getOrdersWhereVendorNotPaid"] = Processor.process_getOrdersWhereVendorNotPaid
5031 varun.gupt 5085 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 5086 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5099 varun.gupt 5087 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
94 ashish 5088 
 
5089 
  def process(self, iprot, oprot):
5090 
    (name, type, seqid) = iprot.readMessageBegin()
5091 
    if name not in self._processMap:
5092 
      iprot.skip(TType.STRUCT)
5093 
      iprot.readMessageEnd()
5094 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5095 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5096 
      x.write(oprot)
5097 
      oprot.writeMessageEnd()
5098 
      oprot.trans.flush()
5099 
      return
5100 
    else:
5101 
      self._processMap[name](self, seqid, iprot, oprot)
5102 
    return True
5103 
 
5104 
  def process_createTransaction(self, seqid, iprot, oprot):
5105 
    args = createTransaction_args()
5106 
    args.read(iprot)
5107 
    iprot.readMessageEnd()
5108 
    result = createTransaction_result()
5109 
    try:
132 ashish 5110 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 5111 
    except TransactionServiceException, ex:
5112 
      result.ex = ex
5113 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
5114 
    result.write(oprot)
5115 
    oprot.writeMessageEnd()
5116 
    oprot.trans.flush()
5117 
 
5118 
  def process_getTransaction(self, seqid, iprot, oprot):
5119 
    args = getTransaction_args()
5120 
    args.read(iprot)
5121 
    iprot.readMessageEnd()
5122 
    result = getTransaction_result()
5123 
    try:
5124 
      result.success = self._handler.getTransaction(args.id)
5125 
    except TransactionServiceException, ex:
5126 
      result.ex = ex
5127 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
5128 
    result.write(oprot)
5129 
    oprot.writeMessageEnd()
5130 
    oprot.trans.flush()
5131 
 
5132 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
5133 
    args = getTransactionsForCustomer_args()
5134 
    args.read(iprot)
5135 
    iprot.readMessageEnd()
5136 
    result = getTransactionsForCustomer_result()
5137 
    try:
5138 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
5139 
    except TransactionServiceException, ex:
5140 
      result.ex = ex
5141 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
5142 
    result.write(oprot)
5143 
    oprot.writeMessageEnd()
5144 
    oprot.trans.flush()
5145 
 
132 ashish 5146 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
5147 
    args = getTransactionsForShoppingCartId_args()
5148 
    args.read(iprot)
5149 
    iprot.readMessageEnd()
5150 
    result = getTransactionsForShoppingCartId_result()
5151 
    try:
5152 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
5153 
    except TransactionServiceException, ex:
5154 
      result.ex = ex
5155 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
5156 
    result.write(oprot)
5157 
    oprot.writeMessageEnd()
5158 
    oprot.trans.flush()
5159 
 
94 ashish 5160 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
5161 
    args = getTransactionStatus_args()
5162 
    args.read(iprot)
5163 
    iprot.readMessageEnd()
5164 
    result = getTransactionStatus_result()
5165 
    try:
5166 
      result.success = self._handler.getTransactionStatus(args.transactionId)
5167 
    except TransactionServiceException, ex:
5168 
      result.ex = ex
5169 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
5170 
    result.write(oprot)
5171 
    oprot.writeMessageEnd()
5172 
    oprot.trans.flush()
5173 
 
5174 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
5175 
    args = changeTransactionStatus_args()
5176 
    args.read(iprot)
5177 
    iprot.readMessageEnd()
5178 
    result = changeTransactionStatus_result()
5179 
    try:
5180 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
5181 
    except TransactionServiceException, ex:
5182 
      result.ex = ex
5183 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
5184 
    result.write(oprot)
5185 
    oprot.writeMessageEnd()
5186 
    oprot.trans.flush()
5187 
 
1398 varun.gupt 5188 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
5189 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 5190 
    args.read(iprot)
5191 
    iprot.readMessageEnd()
1398 varun.gupt 5192 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 5193 
    try:
1398 varun.gupt 5194 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 5195 
    except TransactionServiceException, ex:
5196 
      result.ex = ex
1398 varun.gupt 5197 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 5198 
    result.write(oprot)
5199 
    oprot.writeMessageEnd()
5200 
    oprot.trans.flush()
5201 
 
483 rajveer 5202 
  def process_getAllOrders(self, seqid, iprot, oprot):
5203 
    args = getAllOrders_args()
94 ashish 5204 
    args.read(iprot)
5205 
    iprot.readMessageEnd()
483 rajveer 5206 
    result = getAllOrders_result()
94 ashish 5207 
    try:
4801 anupam.sin 5208 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 5209 
    except TransactionServiceException, ex:
5210 
      result.ex = ex
483 rajveer 5211 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 5212 
    result.write(oprot)
5213 
    oprot.writeMessageEnd()
5214 
    oprot.trans.flush()
5215 
 
4133 chandransh 5216 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
5217 
    args = getOrdersInBatch_args()
5218 
    args.read(iprot)
5219 
    iprot.readMessageEnd()
5220 
    result = getOrdersInBatch_result()
5221 
    try:
5222 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
5223 
    except TransactionServiceException, ex:
5224 
      result.ex = ex
5225 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
5226 
    result.write(oprot)
5227 
    oprot.writeMessageEnd()
5228 
    oprot.trans.flush()
5229 
 
5230 
  def process_getOrderCount(self, seqid, iprot, oprot):
5231 
    args = getOrderCount_args()
5232 
    args.read(iprot)
5233 
    iprot.readMessageEnd()
5234 
    result = getOrderCount_result()
5235 
    try:
5236 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
5237 
    except TransactionServiceException, ex:
5238 
      result.ex = ex
5239 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
5240 
    result.write(oprot)
5241 
    oprot.writeMessageEnd()
5242 
    oprot.trans.flush()
5243 
 
999 varun.gupt 5244 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
5245 
    args = getOrdersByBillingDate_args()
5246 
    args.read(iprot)
5247 
    iprot.readMessageEnd()
5248 
    result = getOrdersByBillingDate_result()
5249 
    try:
5250 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
5251 
    except TransactionServiceException, ex:
5252 
      result.ex = ex
5253 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
5254 
    result.write(oprot)
5255 
    oprot.writeMessageEnd()
5256 
    oprot.trans.flush()
5257 
 
3427 chandransh 5258 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
5259 
    args = getOrdersByShippingDate_args()
5260 
    args.read(iprot)
5261 
    iprot.readMessageEnd()
5262 
    result = getOrdersByShippingDate_result()
5263 
    try:
3451 chandransh 5264 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 5265 
    except TransactionServiceException, ex:
5266 
      result.ex = ex
5267 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
5268 
    result.write(oprot)
5269 
    oprot.writeMessageEnd()
5270 
    oprot.trans.flush()
5271 
 
1382 varun.gupt 5272 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
5273 
    args = getReturnableOrdersForCustomer_args()
5274 
    args.read(iprot)
5275 
    iprot.readMessageEnd()
5276 
    result = getReturnableOrdersForCustomer_result()
5277 
    try:
5278 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
5279 
    except TransactionServiceException, ex:
5280 
      result.ex = ex
5281 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
5282 
    result.write(oprot)
5283 
    oprot.writeMessageEnd()
5284 
    oprot.trans.flush()
5285 
 
5286 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
5287 
    args = getCancellableOrdersForCustomer_args()
5288 
    args.read(iprot)
5289 
    iprot.readMessageEnd()
5290 
    result = getCancellableOrdersForCustomer_result()
5291 
    try:
5292 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
5293 
    except TransactionServiceException, ex:
5294 
      result.ex = ex
5295 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
5296 
    result.write(oprot)
5297 
    oprot.writeMessageEnd()
5298 
    oprot.trans.flush()
5299 
 
483 rajveer 5300 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
5301 
    args = changeOrderStatus_args()
94 ashish 5302 
    args.read(iprot)
5303 
    iprot.readMessageEnd()
483 rajveer 5304 
    result = changeOrderStatus_result()
94 ashish 5305 
    try:
483 rajveer 5306 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 5307 
    except TransactionServiceException, ex:
5308 
      result.ex = ex
483 rajveer 5309 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 5310 
    result.write(oprot)
5311 
    oprot.writeMessageEnd()
5312 
    oprot.trans.flush()
5313 
 
483 rajveer 5314 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
5315 
    args = getOrdersForTransaction_args()
94 ashish 5316 
    args.read(iprot)
5317 
    iprot.readMessageEnd()
483 rajveer 5318 
    result = getOrdersForTransaction_result()
94 ashish 5319 
    try:
1528 ankur.sing 5320 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 5321 
    except TransactionServiceException, ex:
5322 
      result.ex = ex
483 rajveer 5323 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 5324 
    result.write(oprot)
5325 
    oprot.writeMessageEnd()
5326 
    oprot.trans.flush()
5327 
 
483 rajveer 5328 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
5329 
    args = getOrdersForCustomer_args()
94 ashish 5330 
    args.read(iprot)
5331 
    iprot.readMessageEnd()
483 rajveer 5332 
    result = getOrdersForCustomer_result()
94 ashish 5333 
    try:
3014 chandransh 5334 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 5335 
    except TransactionServiceException, ex:
5336 
      result.ex = ex
483 rajveer 5337 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 5338 
    result.write(oprot)
5339 
    oprot.writeMessageEnd()
5340 
    oprot.trans.flush()
5341 
 
483 rajveer 5342 
  def process_createOrder(self, seqid, iprot, oprot):
5343 
    args = createOrder_args()
94 ashish 5344 
    args.read(iprot)
5345 
    iprot.readMessageEnd()
483 rajveer 5346 
    result = createOrder_result()
94 ashish 5347 
    try:
483 rajveer 5348 
      result.success = self._handler.createOrder(args.order)
94 ashish 5349 
    except TransactionServiceException, ex:
5350 
      result.ex = ex
483 rajveer 5351 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 5352 
    result.write(oprot)
5353 
    oprot.writeMessageEnd()
5354 
    oprot.trans.flush()
5355 
 
483 rajveer 5356 
  def process_getOrder(self, seqid, iprot, oprot):
5357 
    args = getOrder_args()
94 ashish 5358 
    args.read(iprot)
5359 
    iprot.readMessageEnd()
483 rajveer 5360 
    result = getOrder_result()
94 ashish 5361 
    try:
483 rajveer 5362 
      result.success = self._handler.getOrder(args.id)
94 ashish 5363 
    except TransactionServiceException, ex:
5364 
      result.ex = ex
483 rajveer 5365 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 5366 
    result.write(oprot)
5367 
    oprot.writeMessageEnd()
5368 
    oprot.trans.flush()
5369 
 
483 rajveer 5370 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
5371 
    args = getLineItemsForOrder_args()
94 ashish 5372 
    args.read(iprot)
5373 
    iprot.readMessageEnd()
483 rajveer 5374 
    result = getLineItemsForOrder_result()
94 ashish 5375 
    try:
483 rajveer 5376 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 5377 
    except TransactionServiceException, ex:
5378 
      result.ex = ex
483 rajveer 5379 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 5380 
    result.write(oprot)
5381 
    oprot.writeMessageEnd()
5382 
    oprot.trans.flush()
5383 
 
4999 phani.kuma 5384 
  def process_getOrderList(self, seqid, iprot, oprot):
5385 
    args = getOrderList_args()
5386 
    args.read(iprot)
5387 
    iprot.readMessageEnd()
5388 
    result = getOrderList_result()
5389 
    result.success = self._handler.getOrderList(args.order_ids)
5390 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
5391 
    result.write(oprot)
5392 
    oprot.writeMessageEnd()
5393 
    oprot.trans.flush()
5394 
 
1528 ankur.sing 5395 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
5396 
    args = getOrderForCustomer_args()
5397 
    args.read(iprot)
5398 
    iprot.readMessageEnd()
5399 
    result = getOrderForCustomer_result()
5400 
    try:
5401 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
5402 
    except TransactionServiceException, ex:
5403 
      result.ex = ex
5404 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
5405 
    result.write(oprot)
5406 
    oprot.writeMessageEnd()
5407 
    oprot.trans.flush()
5408 
 
3064 chandransh 5409 
  def process_getAlerts(self, seqid, iprot, oprot):
5410 
    args = getAlerts_args()
5411 
    args.read(iprot)
5412 
    iprot.readMessageEnd()
5413 
    result = getAlerts_result()
4444 rajveer 5414 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 5415 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
5416 
    result.write(oprot)
5417 
    oprot.writeMessageEnd()
5418 
    oprot.trans.flush()
5419 
 
4394 rajveer 5420 
  def process_addAlert(self, seqid, iprot, oprot):
5421 
    args = addAlert_args()
3064 chandransh 5422 
    args.read(iprot)
5423 
    iprot.readMessageEnd()
4394 rajveer 5424 
    result = addAlert_result()
4444 rajveer 5425 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 5426 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 5427 
    result.write(oprot)
5428 
    oprot.writeMessageEnd()
5429 
    oprot.trans.flush()
5430 
 
4444 rajveer 5431 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
5432 
    args = markAlertsAsSeen_args()
5433 
    args.read(iprot)
5434 
    iprot.readMessageEnd()
5435 
    result = markAlertsAsSeen_result()
5436 
    self._handler.markAlertsAsSeen(args.warehouseId)
5437 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
5438 
    result.write(oprot)
5439 
    oprot.writeMessageEnd()
5440 
    oprot.trans.flush()
5441 
 
3064 chandransh 5442 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
5443 
    args = getValidOrderCount_args()
5444 
    args.read(iprot)
5445 
    iprot.readMessageEnd()
5446 
    result = getValidOrderCount_result()
5447 
    result.success = self._handler.getValidOrderCount()
5448 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
5449 
    result.write(oprot)
5450 
    oprot.writeMessageEnd()
5451 
    oprot.trans.flush()
5452 
 
5453 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
5454 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
5455 
    args.read(iprot)
5456 
    iprot.readMessageEnd()
5457 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
5458 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
5459 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
5460 
    result.write(oprot)
5461 
    oprot.writeMessageEnd()
5462 
    oprot.trans.flush()
5463 
 
5464 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
5465 
    args = getValidOrdersAmountRange_args()
5466 
    args.read(iprot)
5467 
    iprot.readMessageEnd()
5468 
    result = getValidOrdersAmountRange_result()
5469 
    result.success = self._handler.getValidOrdersAmountRange()
5470 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
5471 
    result.write(oprot)
5472 
    oprot.writeMessageEnd()
5473 
    oprot.trans.flush()
5474 
 
5475 
  def process_getValidOrders(self, seqid, iprot, oprot):
5476 
    args = getValidOrders_args()
5477 
    args.read(iprot)
5478 
    iprot.readMessageEnd()
5479 
    result = getValidOrders_result()
5480 
    result.success = self._handler.getValidOrders(args.limit)
5481 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
5482 
    result.write(oprot)
5483 
    oprot.writeMessageEnd()
5484 
    oprot.trans.flush()
5485 
 
1220 chandransh 5486 
  def process_batchOrders(self, seqid, iprot, oprot):
5487 
    args = batchOrders_args()
5488 
    args.read(iprot)
5489 
    iprot.readMessageEnd()
5490 
    result = batchOrders_result()
5491 
    try:
5492 
      result.success = self._handler.batchOrders(args.warehouseId)
5493 
    except TransactionServiceException, ex:
5494 
      result.ex = ex
5495 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
5496 
    result.write(oprot)
5497 
    oprot.writeMessageEnd()
5498 
    oprot.trans.flush()
5499 
 
1208 chandransh 5500 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
5501 
    args = markOrderAsOutOfStock_args()
5502 
    args.read(iprot)
5503 
    iprot.readMessageEnd()
5504 
    result = markOrderAsOutOfStock_result()
5505 
    try:
5506 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
5507 
    except TransactionServiceException, ex:
5508 
      result.ex = ex
5509 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
5510 
    result.write(oprot)
5511 
    oprot.writeMessageEnd()
5512 
    oprot.trans.flush()
5513 
 
3064 chandransh 5514 
  def process_verifyOrder(self, seqid, iprot, oprot):
5515 
    args = verifyOrder_args()
759 chandransh 5516 
    args.read(iprot)
5517 
    iprot.readMessageEnd()
3064 chandransh 5518 
    result = verifyOrder_result()
759 chandransh 5519 
    try:
3064 chandransh 5520 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 5521 
    except TransactionServiceException, ex:
5522 
      result.ex = ex
3064 chandransh 5523 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 5524 
    result.write(oprot)
5525 
    oprot.writeMessageEnd()
5526 
    oprot.trans.flush()
5527 
 
3064 chandransh 5528 
  def process_acceptOrder(self, seqid, iprot, oprot):
5529 
    args = acceptOrder_args()
1113 chandransh 5530 
    args.read(iprot)
5531 
    iprot.readMessageEnd()
3064 chandransh 5532 
    result = acceptOrder_result()
1113 chandransh 5533 
    try:
3064 chandransh 5534 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 5535 
    except TransactionServiceException, ex:
5536 
      result.ex = ex
3064 chandransh 5537 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 5538 
    result.write(oprot)
5539 
    oprot.writeMessageEnd()
5540 
    oprot.trans.flush()
5541 
 
3064 chandransh 5542 
  def process_addBillingDetails(self, seqid, iprot, oprot):
5543 
    args = addBillingDetails_args()
1135 chandransh 5544 
    args.read(iprot)
5545 
    iprot.readMessageEnd()
3064 chandransh 5546 
    result = addBillingDetails_result()
1135 chandransh 5547 
    try:
5110 mandeep.dh 5548 
      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 5549 
    except TransactionServiceException, ex:
5550 
      result.ex = ex
3064 chandransh 5551 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 5552 
    result.write(oprot)
5553 
    oprot.writeMessageEnd()
5554 
    oprot.trans.flush()
5555 
 
4579 rajveer 5556 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
5557 
    args = addInvoiceNumber_args()
5558 
    args.read(iprot)
5559 
    iprot.readMessageEnd()
5560 
    result = addInvoiceNumber_result()
5561 
    try:
4763 rajveer 5562 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 5563 
    except TransactionServiceException, ex:
5564 
      result.ex = ex
5565 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
5566 
    result.write(oprot)
5567 
    oprot.writeMessageEnd()
5568 
    oprot.trans.flush()
5569 
 
4410 rajveer 5570 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5571 
    args = markOrdersAsShippedFromWarehouse_args()
5572 
    args.read(iprot)
5573 
    iprot.readMessageEnd()
5574 
    result = markOrdersAsShippedFromWarehouse_result()
5575 
    try:
4789 rajveer 5576 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 5577 
    except TransactionServiceException, ex:
5578 
      result.ex = ex
5579 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5580 
    result.write(oprot)
5581 
    oprot.writeMessageEnd()
5582 
    oprot.trans.flush()
5583 
 
3064 chandransh 5584 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5585 
    args = markOrdersAsPickedUp_args()
304 ashish 5586 
    args.read(iprot)
5587 
    iprot.readMessageEnd()
3064 chandransh 5588 
    result = markOrdersAsPickedUp_result()
5589 
    try:
4910 phani.kuma 5590 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 5591 
    except TransactionServiceException, ex:
5592 
      result.ex = ex
5593 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5594 
    result.write(oprot)
5595 
    oprot.writeMessageEnd()
5596 
    oprot.trans.flush()
94 ashish 5597 
 
4910 phani.kuma 5598 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
5599 
    args = getOrdersNotPickedUp_args()
5600 
    args.read(iprot)
5601 
    iprot.readMessageEnd()
5602 
    result = getOrdersNotPickedUp_result()
5603 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
5604 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
5605 
    result.write(oprot)
5606 
    oprot.writeMessageEnd()
5607 
    oprot.trans.flush()
5608 
 
3064 chandransh 5609 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5610 
    args = markOrdersAsDelivered_args()
304 ashish 5611 
    args.read(iprot)
5612 
    iprot.readMessageEnd()
3064 chandransh 5613 
    result = markOrdersAsDelivered_result()
5614 
    try:
5615 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5616 
    except TransactionServiceException, ex:
5617 
      result.ex = ex
5618 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5619 
    result.write(oprot)
5620 
    oprot.writeMessageEnd()
5621 
    oprot.trans.flush()
5622 
 
4910 phani.kuma 5623 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
5624 
    args = markAsRTOrders_args()
1596 ankur.sing 5625 
    args.read(iprot)
5626 
    iprot.readMessageEnd()
4910 phani.kuma 5627 
    result = markAsRTOrders_result()
3064 chandransh 5628 
    try:
4910 phani.kuma 5629 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 5630 
    except TransactionServiceException, ex:
5631 
      result.ex = ex
4910 phani.kuma 5632 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 5633 
    result.write(oprot)
5634 
    oprot.writeMessageEnd()
5635 
    oprot.trans.flush()
304 ashish 5636 
 
4910 phani.kuma 5637 
  def process_getRTOrders(self, seqid, iprot, oprot):
5638 
    args = getRTOrders_args()
5639 
    args.read(iprot)
5640 
    iprot.readMessageEnd()
5641 
    result = getRTOrders_result()
5642 
    result.success = self._handler.getRTOrders(args.providerId)
5643 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
5644 
    result.write(oprot)
5645 
    oprot.writeMessageEnd()
5646 
    oprot.trans.flush()
5647 
 
3064 chandransh 5648 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5649 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5650 
    args.read(iprot)
5651 
    iprot.readMessageEnd()
3064 chandransh 5652 
    result = updateNonDeliveryReason_result()
5653 
    try:
4910 phani.kuma 5654 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5655 
    except TransactionServiceException, ex:
5656 
      result.ex = ex
5657 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5658 
    result.write(oprot)
5659 
    oprot.writeMessageEnd()
5660 
    oprot.trans.flush()
1596 ankur.sing 5661 
 
4910 phani.kuma 5662 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
5663 
    args = getNonDeliveredOrdersbyCourier_args()
5664 
    args.read(iprot)
5665 
    iprot.readMessageEnd()
5666 
    result = getNonDeliveredOrdersbyCourier_result()
5667 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
5668 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
5669 
    result.write(oprot)
5670 
    oprot.writeMessageEnd()
5671 
    oprot.trans.flush()
5672 
 
5673 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
5674 
    args = markOrdersAsLocalConnected_args()
5675 
    args.read(iprot)
5676 
    iprot.readMessageEnd()
5677 
    result = markOrdersAsLocalConnected_result()
5678 
    try:
5679 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
5680 
    except TransactionServiceException, ex:
5681 
      result.ex = ex
5682 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
5683 
    result.write(oprot)
5684 
    oprot.writeMessageEnd()
5685 
    oprot.trans.flush()
5686 
 
5687 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
5688 
    args = getOrdersNotLocalConnected_args()
5689 
    args.read(iprot)
5690 
    iprot.readMessageEnd()
5691 
    result = getOrdersNotLocalConnected_result()
5692 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
5693 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
5694 
    result.write(oprot)
5695 
    oprot.writeMessageEnd()
5696 
    oprot.trans.flush()
5697 
 
5698 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
5699 
    args = markOrdersAsDestinationCityReached_args()
5700 
    args.read(iprot)
5701 
    iprot.readMessageEnd()
5702 
    result = markOrdersAsDestinationCityReached_result()
5703 
    try:
5704 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
5705 
    except TransactionServiceException, ex:
5706 
      result.ex = ex
5707 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
5708 
    result.write(oprot)
5709 
    oprot.writeMessageEnd()
5710 
    oprot.trans.flush()
5711 
 
5712 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
5713 
    args = markOrdersAsFirstDeliveryAttempted_args()
5714 
    args.read(iprot)
5715 
    iprot.readMessageEnd()
5716 
    result = markOrdersAsFirstDeliveryAttempted_result()
5717 
    try:
5718 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
5719 
    except TransactionServiceException, ex:
5720 
      result.ex = ex
5721 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
5722 
    result.write(oprot)
5723 
    oprot.writeMessageEnd()
5724 
    oprot.trans.flush()
5725 
 
3064 chandransh 5726 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5727 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5728 
    args.read(iprot)
5729 
    iprot.readMessageEnd()
3064 chandransh 5730 
    result = getUndeliveredOrders_result()
5731 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5732 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5733 
    result.write(oprot)
5734 
    oprot.writeMessageEnd()
5735 
    oprot.trans.flush()
5736 
 
4783 phani.kuma 5737 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
5738 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
5739 
    args.read(iprot)
5740 
    iprot.readMessageEnd()
5741 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
5742 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
5743 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
5744 
    result.write(oprot)
5745 
    oprot.writeMessageEnd()
5746 
    oprot.trans.flush()
5747 
 
2536 chandransh 5748 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5749 
    args = toggleDOAFlag_args()
5750 
    args.read(iprot)
5751 
    iprot.readMessageEnd()
5752 
    result = toggleDOAFlag_result()
5753 
    try:
5754 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5755 
    except TransactionServiceException, ex:
5756 
      result.ex = ex
5757 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5758 
    result.write(oprot)
5759 
    oprot.writeMessageEnd()
5760 
    oprot.trans.flush()
1886 ankur.sing 5761 
 
4712 rajveer 5762 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5763 
    args = markOrderAsDelivered_args()
5764 
    args.read(iprot)
5765 
    iprot.readMessageEnd()
5766 
    result = markOrderAsDelivered_result()
5767 
    try:
5768 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5769 
    except TransactionServiceException, ex:
5770 
      result.ex = ex
5771 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5772 
    result.write(oprot)
5773 
    oprot.writeMessageEnd()
5774 
    oprot.trans.flush()
5775 
 
4454 rajveer 5776 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5777 
    args = markOrderDoaRequestReceived_args()
5778 
    args.read(iprot)
5779 
    iprot.readMessageEnd()
5780 
    result = markOrderDoaRequestReceived_result()
5781 
    try:
5782 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5783 
    except TransactionServiceException, ex:
5784 
      result.ex = ex
5785 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5786 
    result.write(oprot)
5787 
    oprot.writeMessageEnd()
5788 
    oprot.trans.flush()
5789 
 
5790 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
5791 
    args = markOrderDoaRequestAuthorized_args()
5792 
    args.read(iprot)
5793 
    iprot.readMessageEnd()
5794 
    result = markOrderDoaRequestAuthorized_result()
5795 
    try:
5796 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
5797 
    except TransactionServiceException, ex:
5798 
      result.ex = ex
5799 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
5800 
    result.write(oprot)
5801 
    oprot.writeMessageEnd()
5802 
    oprot.trans.flush()
5803 
 
4488 rajveer 5804 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5805 
    args = markOrderReturnRequestReceived_args()
5806 
    args.read(iprot)
5807 
    iprot.readMessageEnd()
5808 
    result = markOrderReturnRequestReceived_result()
5809 
    try:
5810 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5811 
    except TransactionServiceException, ex:
5812 
      result.ex = ex
5813 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5814 
    result.write(oprot)
5815 
    oprot.writeMessageEnd()
5816 
    oprot.trans.flush()
5817 
 
5818 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5819 
    args = markOrderReturnRequestAuthorized_args()
5820 
    args.read(iprot)
5821 
    iprot.readMessageEnd()
5822 
    result = markOrderReturnRequestAuthorized_result()
5823 
    try:
5824 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5825 
    except TransactionServiceException, ex:
5826 
      result.ex = ex
5827 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5828 
    result.write(oprot)
5829 
    oprot.writeMessageEnd()
5830 
    oprot.trans.flush()
5831 
 
2536 chandransh 5832 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5833 
    args = requestPickupNumber_args()
5834 
    args.read(iprot)
5835 
    iprot.readMessageEnd()
5836 
    result = requestPickupNumber_result()
5837 
    try:
4579 rajveer 5838 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 5839 
    except TransactionServiceException, ex:
5840 
      result.ex = ex
5841 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
5842 
    result.write(oprot)
5843 
    oprot.writeMessageEnd()
5844 
    oprot.trans.flush()
5845 
 
5846 
  def process_authorizePickup(self, seqid, iprot, oprot):
5847 
    args = authorizePickup_args()
5848 
    args.read(iprot)
5849 
    iprot.readMessageEnd()
5850 
    result = authorizePickup_result()
5851 
    try:
4602 rajveer 5852 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 5853 
    except TransactionServiceException, ex:
5854 
      result.ex = ex
5855 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
5856 
    result.write(oprot)
5857 
    oprot.writeMessageEnd()
5858 
    oprot.trans.flush()
5859 
 
2764 chandransh 5860 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
5861 
    args = markDoasAsPickedUp_args()
5862 
    args.read(iprot)
5863 
    iprot.readMessageEnd()
5864 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 5865 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 5866 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
5867 
    result.write(oprot)
5868 
    oprot.writeMessageEnd()
5869 
    oprot.trans.flush()
5870 
 
4910 phani.kuma 5871 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
5872 
    args = getDoasNotPickedUp_args()
5873 
    args.read(iprot)
5874 
    iprot.readMessageEnd()
5875 
    result = getDoasNotPickedUp_result()
5876 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
5877 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
5878 
    result.write(oprot)
5879 
    oprot.writeMessageEnd()
5880 
    oprot.trans.flush()
5881 
 
4741 phani.kuma 5882 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
5883 
    args = markReturnOrdersAsPickedUp_args()
5884 
    args.read(iprot)
5885 
    iprot.readMessageEnd()
5886 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 5887 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 5888 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
5889 
    result.write(oprot)
5890 
    oprot.writeMessageEnd()
5891 
    oprot.trans.flush()
5892 
 
4910 phani.kuma 5893 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
5894 
    args = getReturnOrdersNotPickedUp_args()
5895 
    args.read(iprot)
5896 
    iprot.readMessageEnd()
5897 
    result = getReturnOrdersNotPickedUp_result()
5898 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
5899 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
5900 
    result.write(oprot)
5901 
    oprot.writeMessageEnd()
5902 
    oprot.trans.flush()
5903 
 
2616 chandransh 5904 
  def process_receiveReturn(self, seqid, iprot, oprot):
5905 
    args = receiveReturn_args()
2591 chandransh 5906 
    args.read(iprot)
5907 
    iprot.readMessageEnd()
2616 chandransh 5908 
    result = receiveReturn_result()
2591 chandransh 5909 
    try:
4479 rajveer 5910 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 5911 
    except TransactionServiceException, ex:
5912 
      result.ex = ex
2616 chandransh 5913 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 5914 
    result.write(oprot)
5915 
    oprot.writeMessageEnd()
5916 
    oprot.trans.flush()
2536 chandransh 5917 
 
2591 chandransh 5918 
  def process_validateDoa(self, seqid, iprot, oprot):
5919 
    args = validateDoa_args()
5920 
    args.read(iprot)
5921 
    iprot.readMessageEnd()
5922 
    result = validateDoa_result()
5923 
    try:
5924 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
5925 
    except TransactionServiceException, ex:
5926 
      result.ex = ex
5927 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
5928 
    result.write(oprot)
5929 
    oprot.writeMessageEnd()
5930 
    oprot.trans.flush()
5931 
 
4495 rajveer 5932 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
5933 
    args = validateReturnProduct_args()
5934 
    args.read(iprot)
5935 
    iprot.readMessageEnd()
5936 
    result = validateReturnProduct_result()
5937 
    try:
5938 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
5939 
    except TransactionServiceException, ex:
5940 
      result.ex = ex
5941 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
5942 
    result.write(oprot)
5943 
    oprot.writeMessageEnd()
5944 
    oprot.trans.flush()
5945 
 
2616 chandransh 5946 
  def process_reshipOrder(self, seqid, iprot, oprot):
5947 
    args = reshipOrder_args()
5948 
    args.read(iprot)
5949 
    iprot.readMessageEnd()
5950 
    result = reshipOrder_result()
5951 
    try:
5952 
      result.success = self._handler.reshipOrder(args.orderId)
5953 
    except TransactionServiceException, ex:
5954 
      result.ex = ex
5955 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
5956 
    result.write(oprot)
5957 
    oprot.writeMessageEnd()
5958 
    oprot.trans.flush()
2591 chandransh 5959 
 
2616 chandransh 5960 
  def process_refundOrder(self, seqid, iprot, oprot):
5961 
    args = refundOrder_args()
5962 
    args.read(iprot)
5963 
    iprot.readMessageEnd()
5964 
    result = refundOrder_result()
5965 
    try:
3226 chandransh 5966 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 5967 
    except TransactionServiceException, ex:
5968 
      result.ex = ex
5969 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
5970 
    result.write(oprot)
5971 
    oprot.writeMessageEnd()
5972 
    oprot.trans.flush()
5973 
 
2690 chandransh 5974 
  def process_getReturnOrders(self, seqid, iprot, oprot):
5975 
    args = getReturnOrders_args()
5976 
    args.read(iprot)
5977 
    iprot.readMessageEnd()
5978 
    result = getReturnOrders_result()
5979 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
5980 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
5981 
    result.write(oprot)
5982 
    oprot.writeMessageEnd()
5983 
    oprot.trans.flush()
2616 chandransh 5984 
 
2700 chandransh 5985 
  def process_getReturnOrder(self, seqid, iprot, oprot):
5986 
    args = getReturnOrder_args()
5987 
    args.read(iprot)
5988 
    iprot.readMessageEnd()
5989 
    result = getReturnOrder_result()
5990 
    try:
5991 
      result.success = self._handler.getReturnOrder(args.id)
5992 
    except TransactionServiceException, ex:
5993 
      result.ex = ex
5994 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
5995 
    result.write(oprot)
5996 
    oprot.writeMessageEnd()
5997 
    oprot.trans.flush()
5998 
 
2690 chandransh 5999 
  def process_processReturn(self, seqid, iprot, oprot):
6000 
    args = processReturn_args()
6001 
    args.read(iprot)
6002 
    iprot.readMessageEnd()
6003 
    result = processReturn_result()
6004 
    try:
6005 
      self._handler.processReturn(args.returnOrderId)
6006 
    except TransactionServiceException, ex:
6007 
      result.ex = ex
6008 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
6009 
    result.write(oprot)
6010 
    oprot.writeMessageEnd()
6011 
    oprot.trans.flush()
6012 
 
3451 chandransh 6013 
  def process_updateWeight(self, seqid, iprot, oprot):
6014 
    args = updateWeight_args()
6015 
    args.read(iprot)
6016 
    iprot.readMessageEnd()
6017 
    result = updateWeight_result()
6018 
    try:
6019 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
6020 
    except TransactionServiceException, ex:
6021 
      result.ex = ex
6022 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
6023 
    result.write(oprot)
6024 
    oprot.writeMessageEnd()
6025 
    oprot.trans.flush()
2819 chandransh 6026 
 
3469 chandransh 6027 
  def process_changeItem(self, seqid, iprot, oprot):
6028 
    args = changeItem_args()
6029 
    args.read(iprot)
6030 
    iprot.readMessageEnd()
6031 
    result = changeItem_result()
6032 
    try:
6033 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
6034 
    except TransactionServiceException, ex:
6035 
      result.ex = ex
6036 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
6037 
    result.write(oprot)
6038 
    oprot.writeMessageEnd()
6039 
    oprot.trans.flush()
3451 chandransh 6040 
 
3469 chandransh 6041 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
6042 
    args = shiftToWarehouse_args()
6043 
    args.read(iprot)
6044 
    iprot.readMessageEnd()
6045 
    result = shiftToWarehouse_result()
6046 
    try:
6047 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
6048 
    except TransactionServiceException, ex:
6049 
      result.ex = ex
6050 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
6051 
    result.write(oprot)
6052 
    oprot.writeMessageEnd()
6053 
    oprot.trans.flush()
6054 
 
3553 chandransh 6055 
  def process_addDelayReason(self, seqid, iprot, oprot):
6056 
    args = addDelayReason_args()
6057 
    args.read(iprot)
6058 
    iprot.readMessageEnd()
6059 
    result = addDelayReason_result()
6060 
    try:
4647 rajveer 6061 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 6062 
    except TransactionServiceException, ex:
6063 
      result.ex = ex
6064 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
6065 
    result.write(oprot)
6066 
    oprot.writeMessageEnd()
6067 
    oprot.trans.flush()
3469 chandransh 6068 
 
3956 chandransh 6069 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
6070 
    args = reconcileCodCollection_args()
6071 
    args.read(iprot)
6072 
    iprot.readMessageEnd()
6073 
    result = reconcileCodCollection_result()
6074 
    try:
6075 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
6076 
    except TransactionServiceException, ex:
6077 
      result.ex = ex
6078 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
6079 
    result.write(oprot)
6080 
    oprot.writeMessageEnd()
6081 
    oprot.trans.flush()
3553 chandransh 6082 
 
4008 mandeep.dh 6083 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
6084 
    args = getTransactionsRequiringExtraProcessing_args()
6085 
    args.read(iprot)
6086 
    iprot.readMessageEnd()
6087 
    result = getTransactionsRequiringExtraProcessing_result()
6088 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
6089 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
6090 
    result.write(oprot)
6091 
    oprot.writeMessageEnd()
6092 
    oprot.trans.flush()
3956 chandransh 6093 
 
4008 mandeep.dh 6094 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
6095 
    args = markTransactionAsProcessed_args()
6096 
    args.read(iprot)
6097 
    iprot.readMessageEnd()
6098 
    result = markTransactionAsProcessed_result()
6099 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
6100 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
6101 
    result.write(oprot)
6102 
    oprot.writeMessageEnd()
6103 
    oprot.trans.flush()
6104 
 
4018 chandransh 6105 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
6106 
    args = getItemWiseRiskyOrdersCount_args()
6107 
    args.read(iprot)
6108 
    iprot.readMessageEnd()
6109 
    result = getItemWiseRiskyOrdersCount_result()
6110 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
6111 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
6112 
    result.write(oprot)
6113 
    oprot.writeMessageEnd()
6114 
    oprot.trans.flush()
4008 mandeep.dh 6115 
 
4295 varun.gupt 6116 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
6117 
    args = getOrdersForItemIds_args()
6118 
    args.read(iprot)
6119 
    iprot.readMessageEnd()
6120 
    result = getOrdersForItemIds_result()
6121 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
6122 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
6123 
    result.write(oprot)
6124 
    oprot.writeMessageEnd()
6125 
    oprot.trans.flush()
6126 
 
4247 rajveer 6127 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
6128 
    args = markOrderCancellationRequestReceived_args()
6129 
    args.read(iprot)
6130 
    iprot.readMessageEnd()
6131 
    result = markOrderCancellationRequestReceived_result()
6132 
    try:
6133 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
6134 
    except TransactionServiceException, ex:
6135 
      result.ex = ex
6136 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
6137 
    result.write(oprot)
6138 
    oprot.writeMessageEnd()
6139 
    oprot.trans.flush()
4018 chandransh 6140 
 
4247 rajveer 6141 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
6142 
    args = markOrderCancellationRequestConfirmed_args()
6143 
    args.read(iprot)
6144 
    iprot.readMessageEnd()
6145 
    result = markOrderCancellationRequestConfirmed_result()
6146 
    try:
6147 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
6148 
    except TransactionServiceException, ex:
6149 
      result.ex = ex
6150 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
6151 
    result.write(oprot)
6152 
    oprot.writeMessageEnd()
6153 
    oprot.trans.flush()
6154 
 
6155 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
6156 
    args = markOrderCancellationRequestDenied_args()
6157 
    args.read(iprot)
6158 
    iprot.readMessageEnd()
6159 
    result = markOrderCancellationRequestDenied_result()
6160 
    try:
6161 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
6162 
    except TransactionServiceException, ex:
6163 
      result.ex = ex
6164 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
6165 
    result.write(oprot)
6166 
    oprot.writeMessageEnd()
6167 
    oprot.trans.flush()
6168 
 
4258 rajveer 6169 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
6170 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 6171 
    args.read(iprot)
6172 
    iprot.readMessageEnd()
4258 rajveer 6173 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 6174 
    try:
4258 rajveer 6175 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 6176 
    except TransactionServiceException, ex:
6177 
      result.ex = ex
4258 rajveer 6178 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 6179 
    result.write(oprot)
6180 
    oprot.writeMessageEnd()
6181 
    oprot.trans.flush()
6182 
 
4259 anupam.sin 6183 
  def process_refundTransaction(self, seqid, iprot, oprot):
6184 
    args = refundTransaction_args()
6185 
    args.read(iprot)
6186 
    iprot.readMessageEnd()
6187 
    result = refundTransaction_result()
6188 
    try:
6189 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
6190 
    except TransactionServiceException, ex:
6191 
      result.ex = ex
6192 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
6193 
    result.write(oprot)
6194 
    oprot.writeMessageEnd()
6195 
    oprot.trans.flush()
4247 rajveer 6196 
 
4324 mandeep.dh 6197 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
6198 
    args = updateShipmentAddress_args()
6199 
    args.read(iprot)
6200 
    iprot.readMessageEnd()
6201 
    result = updateShipmentAddress_result()
6202 
    try:
6203 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
6204 
    except TransactionServiceException, ex:
6205 
      result.ex = ex
6206 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
6207 
    result.write(oprot)
6208 
    oprot.writeMessageEnd()
6209 
    oprot.trans.flush()
6210 
 
4285 rajveer 6211 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
6212 
    args = acceptOrdersForItemId_args()
6213 
    args.read(iprot)
6214 
    iprot.readMessageEnd()
6215 
    result = acceptOrdersForItemId_result()
6216 
    try:
6217 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
6218 
    except TransactionServiceException, ex:
6219 
      result.ex = ex
6220 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
6221 
    result.write(oprot)
6222 
    oprot.writeMessageEnd()
6223 
    oprot.trans.flush()
4259 anupam.sin 6224 
 
4303 rajveer 6225 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
6226 
    args = markOrdersAsPORaised_args()
6227 
    args.read(iprot)
6228 
    iprot.readMessageEnd()
6229 
    result = markOrdersAsPORaised_result()
6230 
    try:
4369 rajveer 6231 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6232 
    except TransactionServiceException, ex:
6233 
      result.ex = ex
6234 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
6235 
    result.write(oprot)
6236 
    oprot.writeMessageEnd()
6237 
    oprot.trans.flush()
4285 rajveer 6238 
 
4303 rajveer 6239 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
6240 
    args = markOrdersAsReversalInitiated_args()
6241 
    args.read(iprot)
6242 
    iprot.readMessageEnd()
6243 
    result = markOrdersAsReversalInitiated_result()
6244 
    try:
4369 rajveer 6245 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6246 
    except TransactionServiceException, ex:
6247 
      result.ex = ex
6248 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
6249 
    result.write(oprot)
6250 
    oprot.writeMessageEnd()
6251 
    oprot.trans.flush()
6252 
 
6253 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
6254 
    args = markOrdersAsNotAvailabke_args()
6255 
    args.read(iprot)
6256 
    iprot.readMessageEnd()
6257 
    result = markOrdersAsNotAvailabke_result()
6258 
    try:
4369 rajveer 6259 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6260 
    except TransactionServiceException, ex:
6261 
      result.ex = ex
6262 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
6263 
    result.write(oprot)
6264 
    oprot.writeMessageEnd()
6265 
    oprot.trans.flush()
6266 
 
4369 rajveer 6267 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
6268 
    args = markOrdersAsTimeout_args()
6269 
    args.read(iprot)
6270 
    iprot.readMessageEnd()
6271 
    result = markOrdersAsTimeout_result()
6272 
    try:
6273 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
6274 
    except TransactionServiceException, ex:
6275 
      result.ex = ex
6276 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
6277 
    result.write(oprot)
6278 
    oprot.writeMessageEnd()
6279 
    oprot.trans.flush()
4303 rajveer 6280 
 
4662 rajveer 6281 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
6282 
    args = markOrderAsLostInTransit_args()
6283 
    args.read(iprot)
6284 
    iprot.readMessageEnd()
6285 
    result = markOrderAsLostInTransit_result()
6286 
    try:
6287 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
6288 
    except TransactionServiceException, ex:
6289 
      result.ex = ex
6290 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
6291 
    result.write(oprot)
6292 
    oprot.writeMessageEnd()
6293 
    oprot.trans.flush()
6294 
 
4386 anupam.sin 6295 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
6296 
    args = getOrderForAwb_args()
6297 
    args.read(iprot)
6298 
    iprot.readMessageEnd()
6299 
    result = getOrderForAwb_result()
6300 
    try:
6301 
      result.success = self._handler.getOrderForAwb(args.awb)
6302 
    except TransactionServiceException, ex:
6303 
      result.ex = ex
6304 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
6305 
    result.write(oprot)
6306 
    oprot.writeMessageEnd()
6307 
    oprot.trans.flush()
4369 rajveer 6308 
 
4506 phani.kuma 6309 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
6310 
    args = getOrdersForProviderForStatus_args()
6311 
    args.read(iprot)
6312 
    iprot.readMessageEnd()
6313 
    result = getOrdersForProviderForStatus_result()
6314 
    try:
4910 phani.kuma 6315 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 6316 
    except TransactionServiceException, ex:
6317 
      result.ex = ex
6318 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
6319 
    result.write(oprot)
6320 
    oprot.writeMessageEnd()
6321 
    oprot.trans.flush()
4386 anupam.sin 6322 
 
4600 varun.gupt 6323 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
6324 
    args = getBilledOrdersForVendor_args()
6325 
    args.read(iprot)
6326 
    iprot.readMessageEnd()
6327 
    result = getBilledOrdersForVendor_result()
6328 
    try:
6329 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
6330 
    except TransactionServiceException, ex:
6331 
      result.ex = ex
6332 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
6333 
    result.write(oprot)
6334 
    oprot.writeMessageEnd()
6335 
    oprot.trans.flush()
4506 phani.kuma 6336 
 
4607 rajveer 6337 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
6338 
    args = getSlippedSippingDateOrders_args()
6339 
    args.read(iprot)
6340 
    iprot.readMessageEnd()
6341 
    result = getSlippedSippingDateOrders_result()
6342 
    try:
6343 
      result.success = self._handler.getSlippedSippingDateOrders()
6344 
    except TransactionServiceException, ex:
6345 
      result.ex = ex
6346 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
6347 
    result.write(oprot)
6348 
    oprot.writeMessageEnd()
6349 
    oprot.trans.flush()
6350 
 
4709 rajveer 6351 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
6352 
    args = getCancelledOrders_args()
6353 
    args.read(iprot)
6354 
    iprot.readMessageEnd()
6355 
    result = getCancelledOrders_result()
6356 
    try:
6357 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
6358 
    except TransactionServiceException, ex:
6359 
      result.ex = ex
6360 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
6361 
    result.write(oprot)
6362 
    oprot.writeMessageEnd()
6363 
    oprot.trans.flush()
6364 
 
4600 varun.gupt 6365 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
6366 
    args = saveBluedartSettlements_args()
6367 
    args.read(iprot)
6368 
    iprot.readMessageEnd()
6369 
    result = saveBluedartSettlements_result()
6370 
    try:
6371 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
6372 
    except TransactionServiceException, ex:
6373 
      result.ex = ex
6374 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
6375 
    result.write(oprot)
6376 
    oprot.writeMessageEnd()
6377 
    oprot.trans.flush()
6378 
 
6379 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
6380 
    args = savePaymentSettlements_args()
6381 
    args.read(iprot)
6382 
    iprot.readMessageEnd()
6383 
    result = savePaymentSettlements_result()
6384 
    try:
4905 varun.gupt 6385 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 6386 
    except TransactionServiceException, ex:
6387 
      result.ex = ex
6388 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
6389 
    result.write(oprot)
6390 
    oprot.writeMessageEnd()
6391 
    oprot.trans.flush()
6392 
 
6393 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
6394 
    args = saveEBSSettlementSummary_args()
6395 
    args.read(iprot)
6396 
    iprot.readMessageEnd()
6397 
    result = saveEBSSettlementSummary_result()
6398 
    try:
6399 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
6400 
    except TransactionServiceException, ex:
6401 
      result.ex = ex
6402 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
6403 
    result.write(oprot)
6404 
    oprot.writeMessageEnd()
6405 
    oprot.trans.flush()
6406 
 
6407 
  def process_getSettlementForPaymentId(self, seqid, iprot, oprot):
6408 
    args = getSettlementForPaymentId_args()
6409 
    args.read(iprot)
6410 
    iprot.readMessageEnd()
6411 
    result = getSettlementForPaymentId_result()
6412 
    try:
6413 
      result.success = self._handler.getSettlementForPaymentId(args.paymentId)
6414 
    except TransactionServiceException, ex:
6415 
      result.ex = ex
6416 
    oprot.writeMessageBegin("getSettlementForPaymentId", TMessageType.REPLY, seqid)
6417 
    result.write(oprot)
6418 
    oprot.writeMessageEnd()
6419 
    oprot.trans.flush()
6420 
 
6421 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
6422 
    args = getEBSSettlementSummaries_args()
6423 
    args.read(iprot)
6424 
    iprot.readMessageEnd()
6425 
    result = getEBSSettlementSummaries_result()
6426 
    try:
6427 
      result.success = self._handler.getEBSSettlementSummaries()
6428 
    except TransactionServiceException, ex:
6429 
      result.ex = ex
6430 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
6431 
    result.write(oprot)
6432 
    oprot.writeMessageEnd()
6433 
    oprot.trans.flush()
6434 
 
6435 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
6436 
    args = markEBSSettlementUploaded_args()
6437 
    args.read(iprot)
6438 
    iprot.readMessageEnd()
6439 
    result = markEBSSettlementUploaded_result()
6440 
    try:
6441 
      self._handler.markEBSSettlementUploaded(args.settlementId)
6442 
    except TransactionServiceException, ex:
6443 
      result.ex = ex
6444 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
6445 
    result.write(oprot)
6446 
    oprot.writeMessageEnd()
6447 
    oprot.trans.flush()
6448 
 
6449 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
6450 
    args = getEBSSettlementDate_args()
6451 
    args.read(iprot)
6452 
    iprot.readMessageEnd()
6453 
    result = getEBSSettlementDate_result()
6454 
    try:
6455 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
6456 
    except TransactionServiceException, ex:
6457 
      result.ex = ex
6458 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
6459 
    result.write(oprot)
6460 
    oprot.writeMessageEnd()
6461 
    oprot.trans.flush()
6462 
 
4715 varun.gupt 6463 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
6464 
    args = getSettlementsByDate_args()
6465 
    args.read(iprot)
6466 
    iprot.readMessageEnd()
6467 
    result = getSettlementsByDate_result()
6468 
    try:
6469 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
6470 
    except TransactionServiceException, ex:
6471 
      result.ex = ex
6472 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
6473 
    result.write(oprot)
6474 
    oprot.writeMessageEnd()
6475 
    oprot.trans.flush()
4600 varun.gupt 6476 
 
4715 varun.gupt 6477 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
6478 
    args = getReshippedOrderIds_args()
6479 
    args.read(iprot)
6480 
    iprot.readMessageEnd()
6481 
    result = getReshippedOrderIds_result()
6482 
    try:
6483 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
6484 
    except TransactionServiceException, ex:
6485 
      result.ex = ex
6486 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
6487 
    result.write(oprot)
6488 
    oprot.writeMessageEnd()
6489 
    oprot.trans.flush()
6490 
 
4757 mandeep.dh 6491 
  def process_updateOrdersAsPORaised(self, seqid, iprot, oprot):
6492 
    args = updateOrdersAsPORaised_args()
6493 
    args.read(iprot)
6494 
    iprot.readMessageEnd()
6495 
    result = updateOrdersAsPORaised_result()
6496 
    try:
6497 
      self._handler.updateOrdersAsPORaised(args.itemIdQuantityMap, args.purchaseOrderId, args.warehouseId)
6498 
    except TransactionServiceException, ex:
6499 
      result.ex = ex
6500 
    oprot.writeMessageBegin("updateOrdersAsPORaised", TMessageType.REPLY, seqid)
6501 
    result.write(oprot)
6502 
    oprot.writeMessageEnd()
6503 
    oprot.trans.flush()
4715 varun.gupt 6504 
 
4875 varun.gupt 6505 
  def process_getOrdersWhereVendorNotPaid(self, seqid, iprot, oprot):
6506 
    args = getOrdersWhereVendorNotPaid_args()
6507 
    args.read(iprot)
6508 
    iprot.readMessageEnd()
6509 
    result = getOrdersWhereVendorNotPaid_result()
6510 
    try:
6511 
      result.success = self._handler.getOrdersWhereVendorNotPaid(args.vendorId)
6512 
    except TransactionServiceException, ex:
6513 
      result.ex = ex
6514 
    oprot.writeMessageBegin("getOrdersWhereVendorNotPaid", TMessageType.REPLY, seqid)
6515 
    result.write(oprot)
6516 
    oprot.writeMessageEnd()
6517 
    oprot.trans.flush()
4757 mandeep.dh 6518 
 
5031 varun.gupt 6519 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
6520 
    args = getStatusDistributionOfOrders_args()
6521 
    args.read(iprot)
6522 
    iprot.readMessageEnd()
6523 
    result = getStatusDistributionOfOrders_result()
6524 
    try:
6525 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
6526 
    except TransactionServiceException, ex:
6527 
      result.ex = ex
6528 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
6529 
    result.write(oprot)
6530 
    oprot.writeMessageEnd()
6531 
    oprot.trans.flush()
4875 varun.gupt 6532 
 
5067 varun.gupt 6533 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
6534 
    args = getOrderIdsForStatus_args()
6535 
    args.read(iprot)
6536 
    iprot.readMessageEnd()
6537 
    result = getOrderIdsForStatus_result()
6538 
    try:
6539 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
6540 
    except TransactionServiceException, ex:
6541 
      result.ex = ex
6542 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
6543 
    result.write(oprot)
6544 
    oprot.writeMessageEnd()
6545 
    oprot.trans.flush()
5031 varun.gupt 6546 
 
5099 varun.gupt 6547 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
6548 
    args = updateOrderAsPaidToVendor_args()
6549 
    args.read(iprot)
6550 
    iprot.readMessageEnd()
6551 
    result = updateOrderAsPaidToVendor_result()
6552 
    try:
6553 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
6554 
    except TransactionServiceException, ex:
6555 
      result.ex = ex
6556 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
6557 
    result.write(oprot)
6558 
    oprot.writeMessageEnd()
6559 
    oprot.trans.flush()
5067 varun.gupt 6560 
 
5099 varun.gupt 6561 
 
94 ashish 6562 
# HELPER FUNCTIONS AND STRUCTURES
6563 
 
6564 
class createTransaction_args:
6565 
  """
6566 
  Attributes:
6567 
   - transaction
6568 
  """
6569 
 
6570 
  thrift_spec = (
6571 
    None, # 0
6572 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
6573 
  )
6574 
 
6575 
  def __init__(self, transaction=None,):
6576 
    self.transaction = transaction
6577 
 
6578 
  def read(self, iprot):
6579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6581 
      return
6582 
    iprot.readStructBegin()
6583 
    while True:
6584 
      (fname, ftype, fid) = iprot.readFieldBegin()
6585 
      if ftype == TType.STOP:
6586 
        break
6587 
      if fid == 1:
6588 
        if ftype == TType.STRUCT:
6589 
          self.transaction = Transaction()
6590 
          self.transaction.read(iprot)
6591 
        else:
6592 
          iprot.skip(ftype)
6593 
      else:
6594 
        iprot.skip(ftype)
6595 
      iprot.readFieldEnd()
6596 
    iprot.readStructEnd()
6597 
 
6598 
  def write(self, oprot):
6599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6601 
      return
6602 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 6603 
    if self.transaction is not None:
94 ashish 6604 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
6605 
      self.transaction.write(oprot)
6606 
      oprot.writeFieldEnd()
6607 
    oprot.writeFieldStop()
6608 
    oprot.writeStructEnd()
6609 
 
3431 rajveer 6610 
  def validate(self):
6611 
    return
6612 
 
6613 
 
94 ashish 6614 
  def __repr__(self):
6615 
    L = ['%s=%r' % (key, value)
6616 
      for key, value in self.__dict__.iteritems()]
6617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6618 
 
6619 
  def __eq__(self, other):
6620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6621 
 
6622 
  def __ne__(self, other):
6623 
    return not (self == other)
6624 
 
6625 
class createTransaction_result:
6626 
  """
6627 
  Attributes:
132 ashish 6628 
   - success
94 ashish 6629 
   - ex
6630 
  """
6631 
 
6632 
  thrift_spec = (
132 ashish 6633 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 6634 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6635 
  )
6636 
 
132 ashish 6637 
  def __init__(self, success=None, ex=None,):
6638 
    self.success = success
94 ashish 6639 
    self.ex = ex
6640 
 
6641 
  def read(self, iprot):
6642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6644 
      return
6645 
    iprot.readStructBegin()
6646 
    while True:
6647 
      (fname, ftype, fid) = iprot.readFieldBegin()
6648 
      if ftype == TType.STOP:
6649 
        break
132 ashish 6650 
      if fid == 0:
6651 
        if ftype == TType.I64:
6652 
          self.success = iprot.readI64();
6653 
        else:
6654 
          iprot.skip(ftype)
6655 
      elif fid == 1:
94 ashish 6656 
        if ftype == TType.STRUCT:
6657 
          self.ex = TransactionServiceException()
6658 
          self.ex.read(iprot)
6659 
        else:
6660 
          iprot.skip(ftype)
6661 
      else:
6662 
        iprot.skip(ftype)
6663 
      iprot.readFieldEnd()
6664 
    iprot.readStructEnd()
6665 
 
6666 
  def write(self, oprot):
6667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6669 
      return
6670 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 6671 
    if self.success is not None:
132 ashish 6672 
      oprot.writeFieldBegin('success', TType.I64, 0)
6673 
      oprot.writeI64(self.success)
6674 
      oprot.writeFieldEnd()
3431 rajveer 6675 
    if self.ex is not None:
94 ashish 6676 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6677 
      self.ex.write(oprot)
6678 
      oprot.writeFieldEnd()
6679 
    oprot.writeFieldStop()
6680 
    oprot.writeStructEnd()
6681 
 
3431 rajveer 6682 
  def validate(self):
6683 
    return
6684 
 
6685 
 
94 ashish 6686 
  def __repr__(self):
6687 
    L = ['%s=%r' % (key, value)
6688 
      for key, value in self.__dict__.iteritems()]
6689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6690 
 
6691 
  def __eq__(self, other):
6692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6693 
 
6694 
  def __ne__(self, other):
6695 
    return not (self == other)
6696 
 
6697 
class getTransaction_args:
6698 
  """
6699 
  Attributes:
6700 
   - id
6701 
  """
6702 
 
6703 
  thrift_spec = (
6704 
    None, # 0
6705 
    (1, TType.I64, 'id', None, None, ), # 1
6706 
  )
6707 
 
6708 
  def __init__(self, id=None,):
6709 
    self.id = id
6710 
 
6711 
  def read(self, iprot):
6712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6714 
      return
6715 
    iprot.readStructBegin()
6716 
    while True:
6717 
      (fname, ftype, fid) = iprot.readFieldBegin()
6718 
      if ftype == TType.STOP:
6719 
        break
6720 
      if fid == 1:
6721 
        if ftype == TType.I64:
6722 
          self.id = iprot.readI64();
6723 
        else:
6724 
          iprot.skip(ftype)
6725 
      else:
6726 
        iprot.skip(ftype)
6727 
      iprot.readFieldEnd()
6728 
    iprot.readStructEnd()
6729 
 
6730 
  def write(self, oprot):
6731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6733 
      return
6734 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 6735 
    if self.id is not None:
94 ashish 6736 
      oprot.writeFieldBegin('id', TType.I64, 1)
6737 
      oprot.writeI64(self.id)
6738 
      oprot.writeFieldEnd()
6739 
    oprot.writeFieldStop()
6740 
    oprot.writeStructEnd()
6741 
 
3431 rajveer 6742 
  def validate(self):
6743 
    return
6744 
 
6745 
 
94 ashish 6746 
  def __repr__(self):
6747 
    L = ['%s=%r' % (key, value)
6748 
      for key, value in self.__dict__.iteritems()]
6749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6750 
 
6751 
  def __eq__(self, other):
6752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6753 
 
6754 
  def __ne__(self, other):
6755 
    return not (self == other)
6756 
 
6757 
class getTransaction_result:
6758 
  """
6759 
  Attributes:
6760 
   - success
6761 
   - ex
6762 
  """
6763 
 
6764 
  thrift_spec = (
6765 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
6766 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6767 
  )
6768 
 
6769 
  def __init__(self, success=None, ex=None,):
6770 
    self.success = success
6771 
    self.ex = ex
6772 
 
6773 
  def read(self, iprot):
6774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6776 
      return
6777 
    iprot.readStructBegin()
6778 
    while True:
6779 
      (fname, ftype, fid) = iprot.readFieldBegin()
6780 
      if ftype == TType.STOP:
6781 
        break
6782 
      if fid == 0:
6783 
        if ftype == TType.STRUCT:
6784 
          self.success = Transaction()
6785 
          self.success.read(iprot)
6786 
        else:
6787 
          iprot.skip(ftype)
6788 
      elif fid == 1:
6789 
        if ftype == TType.STRUCT:
6790 
          self.ex = TransactionServiceException()
6791 
          self.ex.read(iprot)
6792 
        else:
6793 
          iprot.skip(ftype)
6794 
      else:
6795 
        iprot.skip(ftype)
6796 
      iprot.readFieldEnd()
6797 
    iprot.readStructEnd()
6798 
 
6799 
  def write(self, oprot):
6800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6802 
      return
6803 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 6804 
    if self.success is not None:
94 ashish 6805 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6806 
      self.success.write(oprot)
6807 
      oprot.writeFieldEnd()
3431 rajveer 6808 
    if self.ex is not None:
94 ashish 6809 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6810 
      self.ex.write(oprot)
6811 
      oprot.writeFieldEnd()
6812 
    oprot.writeFieldStop()
6813 
    oprot.writeStructEnd()
6814 
 
3431 rajveer 6815 
  def validate(self):
6816 
    return
6817 
 
6818 
 
94 ashish 6819 
  def __repr__(self):
6820 
    L = ['%s=%r' % (key, value)
6821 
      for key, value in self.__dict__.iteritems()]
6822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6823 
 
6824 
  def __eq__(self, other):
6825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6826 
 
6827 
  def __ne__(self, other):
6828 
    return not (self == other)
6829 
 
6830 
class getTransactionsForCustomer_args:
6831 
  """
6832 
  Attributes:
6833 
   - customerId
6834 
   - from_date
6835 
   - to_date
6836 
   - status
6837 
  """
6838 
 
6839 
  thrift_spec = (
6840 
    None, # 0
6841 
    (1, TType.I64, 'customerId', None, None, ), # 1
6842 
    (2, TType.I64, 'from_date', None, None, ), # 2
6843 
    (3, TType.I64, 'to_date', None, None, ), # 3
6844 
    (4, TType.I32, 'status', None, None, ), # 4
6845 
  )
6846 
 
6847 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
6848 
    self.customerId = customerId
6849 
    self.from_date = from_date
6850 
    self.to_date = to_date
6851 
    self.status = status
6852 
 
6853 
  def read(self, iprot):
6854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6856 
      return
6857 
    iprot.readStructBegin()
6858 
    while True:
6859 
      (fname, ftype, fid) = iprot.readFieldBegin()
6860 
      if ftype == TType.STOP:
6861 
        break
6862 
      if fid == 1:
6863 
        if ftype == TType.I64:
6864 
          self.customerId = iprot.readI64();
6865 
        else:
6866 
          iprot.skip(ftype)
6867 
      elif fid == 2:
6868 
        if ftype == TType.I64:
6869 
          self.from_date = iprot.readI64();
6870 
        else:
6871 
          iprot.skip(ftype)
6872 
      elif fid == 3:
6873 
        if ftype == TType.I64:
6874 
          self.to_date = iprot.readI64();
6875 
        else:
6876 
          iprot.skip(ftype)
6877 
      elif fid == 4:
6878 
        if ftype == TType.I32:
6879 
          self.status = iprot.readI32();
6880 
        else:
6881 
          iprot.skip(ftype)
6882 
      else:
6883 
        iprot.skip(ftype)
6884 
      iprot.readFieldEnd()
6885 
    iprot.readStructEnd()
6886 
 
6887 
  def write(self, oprot):
6888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6890 
      return
6891 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 6892 
    if self.customerId is not None:
94 ashish 6893 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6894 
      oprot.writeI64(self.customerId)
6895 
      oprot.writeFieldEnd()
3431 rajveer 6896 
    if self.from_date is not None:
94 ashish 6897 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6898 
      oprot.writeI64(self.from_date)
6899 
      oprot.writeFieldEnd()
3431 rajveer 6900 
    if self.to_date is not None:
94 ashish 6901 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6902 
      oprot.writeI64(self.to_date)
6903 
      oprot.writeFieldEnd()
3431 rajveer 6904 
    if self.status is not None:
94 ashish 6905 
      oprot.writeFieldBegin('status', TType.I32, 4)
6906 
      oprot.writeI32(self.status)
6907 
      oprot.writeFieldEnd()
6908 
    oprot.writeFieldStop()
6909 
    oprot.writeStructEnd()
6910 
 
3431 rajveer 6911 
  def validate(self):
6912 
    return
6913 
 
6914 
 
94 ashish 6915 
  def __repr__(self):
6916 
    L = ['%s=%r' % (key, value)
6917 
      for key, value in self.__dict__.iteritems()]
6918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6919 
 
6920 
  def __eq__(self, other):
6921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6922 
 
6923 
  def __ne__(self, other):
6924 
    return not (self == other)
6925 
 
6926 
class getTransactionsForCustomer_result:
6927 
  """
6928 
  Attributes:
6929 
   - success
6930 
   - ex
6931 
  """
6932 
 
6933 
  thrift_spec = (
6934 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6935 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6936 
  )
6937 
 
6938 
  def __init__(self, success=None, ex=None,):
6939 
    self.success = success
6940 
    self.ex = ex
6941 
 
6942 
  def read(self, iprot):
6943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6945 
      return
6946 
    iprot.readStructBegin()
6947 
    while True:
6948 
      (fname, ftype, fid) = iprot.readFieldBegin()
6949 
      if ftype == TType.STOP:
6950 
        break
6951 
      if fid == 0:
6952 
        if ftype == TType.LIST:
6953 
          self.success = []
5031 varun.gupt 6954 
          (_etype66, _size63) = iprot.readListBegin()
6955 
          for _i67 in xrange(_size63):
6956 
            _elem68 = Transaction()
6957 
            _elem68.read(iprot)
6958 
            self.success.append(_elem68)
94 ashish 6959 
          iprot.readListEnd()
6960 
        else:
6961 
          iprot.skip(ftype)
6962 
      elif fid == 1:
6963 
        if ftype == TType.STRUCT:
6964 
          self.ex = TransactionServiceException()
6965 
          self.ex.read(iprot)
6966 
        else:
6967 
          iprot.skip(ftype)
6968 
      else:
6969 
        iprot.skip(ftype)
6970 
      iprot.readFieldEnd()
6971 
    iprot.readStructEnd()
6972 
 
6973 
  def write(self, oprot):
6974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6976 
      return
6977 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 6978 
    if self.success is not None:
94 ashish 6979 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6980 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 6981 
      for iter69 in self.success:
6982 
        iter69.write(oprot)
94 ashish 6983 
      oprot.writeListEnd()
6984 
      oprot.writeFieldEnd()
3431 rajveer 6985 
    if self.ex is not None:
94 ashish 6986 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6987 
      self.ex.write(oprot)
6988 
      oprot.writeFieldEnd()
6989 
    oprot.writeFieldStop()
6990 
    oprot.writeStructEnd()
6991 
 
3431 rajveer 6992 
  def validate(self):
6993 
    return
6994 
 
6995 
 
94 ashish 6996 
  def __repr__(self):
6997 
    L = ['%s=%r' % (key, value)
6998 
      for key, value in self.__dict__.iteritems()]
6999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7000 
 
7001 
  def __eq__(self, other):
7002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7003 
 
7004 
  def __ne__(self, other):
7005 
    return not (self == other)
7006 
 
132 ashish 7007 
class getTransactionsForShoppingCartId_args:
7008 
  """
7009 
  Attributes:
7010 
   - shoppingCartId
7011 
  """
7012 
 
7013 
  thrift_spec = (
7014 
    None, # 0
7015 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
7016 
  )
7017 
 
7018 
  def __init__(self, shoppingCartId=None,):
7019 
    self.shoppingCartId = shoppingCartId
7020 
 
7021 
  def read(self, iprot):
7022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7024 
      return
7025 
    iprot.readStructBegin()
7026 
    while True:
7027 
      (fname, ftype, fid) = iprot.readFieldBegin()
7028 
      if ftype == TType.STOP:
7029 
        break
7030 
      if fid == 1:
7031 
        if ftype == TType.I64:
7032 
          self.shoppingCartId = iprot.readI64();
7033 
        else:
7034 
          iprot.skip(ftype)
7035 
      else:
7036 
        iprot.skip(ftype)
7037 
      iprot.readFieldEnd()
7038 
    iprot.readStructEnd()
7039 
 
7040 
  def write(self, oprot):
7041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7043 
      return
7044 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 7045 
    if self.shoppingCartId is not None:
132 ashish 7046 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
7047 
      oprot.writeI64(self.shoppingCartId)
7048 
      oprot.writeFieldEnd()
7049 
    oprot.writeFieldStop()
7050 
    oprot.writeStructEnd()
7051 
 
3431 rajveer 7052 
  def validate(self):
7053 
    return
7054 
 
7055 
 
132 ashish 7056 
  def __repr__(self):
7057 
    L = ['%s=%r' % (key, value)
7058 
      for key, value in self.__dict__.iteritems()]
7059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7060 
 
7061 
  def __eq__(self, other):
7062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7063 
 
7064 
  def __ne__(self, other):
7065 
    return not (self == other)
7066 
 
7067 
class getTransactionsForShoppingCartId_result:
7068 
  """
7069 
  Attributes:
7070 
   - success
7071 
   - ex
7072 
  """
7073 
 
7074 
  thrift_spec = (
7075 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7076 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7077 
  )
7078 
 
7079 
  def __init__(self, success=None, ex=None,):
7080 
    self.success = success
7081 
    self.ex = ex
7082 
 
7083 
  def read(self, iprot):
7084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7086 
      return
7087 
    iprot.readStructBegin()
7088 
    while True:
7089 
      (fname, ftype, fid) = iprot.readFieldBegin()
7090 
      if ftype == TType.STOP:
7091 
        break
7092 
      if fid == 0:
7093 
        if ftype == TType.LIST:
7094 
          self.success = []
5031 varun.gupt 7095 
          (_etype73, _size70) = iprot.readListBegin()
7096 
          for _i74 in xrange(_size70):
7097 
            _elem75 = Transaction()
7098 
            _elem75.read(iprot)
7099 
            self.success.append(_elem75)
132 ashish 7100 
          iprot.readListEnd()
7101 
        else:
7102 
          iprot.skip(ftype)
7103 
      elif fid == 1:
7104 
        if ftype == TType.STRUCT:
7105 
          self.ex = TransactionServiceException()
7106 
          self.ex.read(iprot)
7107 
        else:
7108 
          iprot.skip(ftype)
7109 
      else:
7110 
        iprot.skip(ftype)
7111 
      iprot.readFieldEnd()
7112 
    iprot.readStructEnd()
7113 
 
7114 
  def write(self, oprot):
7115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7117 
      return
7118 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 7119 
    if self.success is not None:
132 ashish 7120 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7121 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7122 
      for iter76 in self.success:
7123 
        iter76.write(oprot)
132 ashish 7124 
      oprot.writeListEnd()
7125 
      oprot.writeFieldEnd()
3431 rajveer 7126 
    if self.ex is not None:
132 ashish 7127 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7128 
      self.ex.write(oprot)
7129 
      oprot.writeFieldEnd()
7130 
    oprot.writeFieldStop()
7131 
    oprot.writeStructEnd()
7132 
 
3431 rajveer 7133 
  def validate(self):
7134 
    return
7135 
 
7136 
 
132 ashish 7137 
  def __repr__(self):
7138 
    L = ['%s=%r' % (key, value)
7139 
      for key, value in self.__dict__.iteritems()]
7140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7141 
 
7142 
  def __eq__(self, other):
7143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7144 
 
7145 
  def __ne__(self, other):
7146 
    return not (self == other)
7147 
 
94 ashish 7148 
class getTransactionStatus_args:
7149 
  """
7150 
  Attributes:
7151 
   - transactionId
7152 
  """
7153 
 
7154 
  thrift_spec = (
7155 
    None, # 0
7156 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7157 
  )
7158 
 
7159 
  def __init__(self, transactionId=None,):
7160 
    self.transactionId = transactionId
7161 
 
7162 
  def read(self, iprot):
7163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7165 
      return
7166 
    iprot.readStructBegin()
7167 
    while True:
7168 
      (fname, ftype, fid) = iprot.readFieldBegin()
7169 
      if ftype == TType.STOP:
7170 
        break
7171 
      if fid == 1:
7172 
        if ftype == TType.I64:
7173 
          self.transactionId = iprot.readI64();
7174 
        else:
7175 
          iprot.skip(ftype)
7176 
      else:
7177 
        iprot.skip(ftype)
7178 
      iprot.readFieldEnd()
7179 
    iprot.readStructEnd()
7180 
 
7181 
  def write(self, oprot):
7182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7184 
      return
7185 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 7186 
    if self.transactionId is not None:
94 ashish 7187 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7188 
      oprot.writeI64(self.transactionId)
7189 
      oprot.writeFieldEnd()
7190 
    oprot.writeFieldStop()
7191 
    oprot.writeStructEnd()
7192 
 
3431 rajveer 7193 
  def validate(self):
7194 
    return
7195 
 
7196 
 
94 ashish 7197 
  def __repr__(self):
7198 
    L = ['%s=%r' % (key, value)
7199 
      for key, value in self.__dict__.iteritems()]
7200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7201 
 
7202 
  def __eq__(self, other):
7203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7204 
 
7205 
  def __ne__(self, other):
7206 
    return not (self == other)
7207 
 
7208 
class getTransactionStatus_result:
7209 
  """
7210 
  Attributes:
7211 
   - success
7212 
   - ex
7213 
  """
7214 
 
7215 
  thrift_spec = (
7216 
    (0, TType.I32, 'success', None, None, ), # 0
7217 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7218 
  )
7219 
 
7220 
  def __init__(self, success=None, ex=None,):
7221 
    self.success = success
7222 
    self.ex = ex
7223 
 
7224 
  def read(self, iprot):
7225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7227 
      return
7228 
    iprot.readStructBegin()
7229 
    while True:
7230 
      (fname, ftype, fid) = iprot.readFieldBegin()
7231 
      if ftype == TType.STOP:
7232 
        break
7233 
      if fid == 0:
7234 
        if ftype == TType.I32:
7235 
          self.success = iprot.readI32();
7236 
        else:
7237 
          iprot.skip(ftype)
7238 
      elif fid == 1:
7239 
        if ftype == TType.STRUCT:
7240 
          self.ex = TransactionServiceException()
7241 
          self.ex.read(iprot)
7242 
        else:
7243 
          iprot.skip(ftype)
7244 
      else:
7245 
        iprot.skip(ftype)
7246 
      iprot.readFieldEnd()
7247 
    iprot.readStructEnd()
7248 
 
7249 
  def write(self, oprot):
7250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7252 
      return
7253 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 7254 
    if self.success is not None:
94 ashish 7255 
      oprot.writeFieldBegin('success', TType.I32, 0)
7256 
      oprot.writeI32(self.success)
7257 
      oprot.writeFieldEnd()
3431 rajveer 7258 
    if self.ex is not None:
94 ashish 7259 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7260 
      self.ex.write(oprot)
7261 
      oprot.writeFieldEnd()
7262 
    oprot.writeFieldStop()
7263 
    oprot.writeStructEnd()
7264 
 
3431 rajveer 7265 
  def validate(self):
7266 
    return
7267 
 
7268 
 
94 ashish 7269 
  def __repr__(self):
7270 
    L = ['%s=%r' % (key, value)
7271 
      for key, value in self.__dict__.iteritems()]
7272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7273 
 
7274 
  def __eq__(self, other):
7275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7276 
 
7277 
  def __ne__(self, other):
7278 
    return not (self == other)
7279 
 
7280 
class changeTransactionStatus_args:
7281 
  """
7282 
  Attributes:
7283 
   - transactionId
7284 
   - status
7285 
   - description
7286 
  """
7287 
 
7288 
  thrift_spec = (
7289 
    None, # 0
7290 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7291 
    (2, TType.I32, 'status', None, None, ), # 2
7292 
    (3, TType.STRING, 'description', None, None, ), # 3
7293 
  )
7294 
 
7295 
  def __init__(self, transactionId=None, status=None, description=None,):
7296 
    self.transactionId = transactionId
7297 
    self.status = status
7298 
    self.description = description
7299 
 
7300 
  def read(self, iprot):
7301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7303 
      return
7304 
    iprot.readStructBegin()
7305 
    while True:
7306 
      (fname, ftype, fid) = iprot.readFieldBegin()
7307 
      if ftype == TType.STOP:
7308 
        break
7309 
      if fid == 1:
7310 
        if ftype == TType.I64:
7311 
          self.transactionId = iprot.readI64();
7312 
        else:
7313 
          iprot.skip(ftype)
7314 
      elif fid == 2:
7315 
        if ftype == TType.I32:
7316 
          self.status = iprot.readI32();
7317 
        else:
7318 
          iprot.skip(ftype)
7319 
      elif fid == 3:
7320 
        if ftype == TType.STRING:
7321 
          self.description = iprot.readString();
7322 
        else:
7323 
          iprot.skip(ftype)
7324 
      else:
7325 
        iprot.skip(ftype)
7326 
      iprot.readFieldEnd()
7327 
    iprot.readStructEnd()
7328 
 
7329 
  def write(self, oprot):
7330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7332 
      return
7333 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 7334 
    if self.transactionId is not None:
94 ashish 7335 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7336 
      oprot.writeI64(self.transactionId)
7337 
      oprot.writeFieldEnd()
3431 rajveer 7338 
    if self.status is not None:
94 ashish 7339 
      oprot.writeFieldBegin('status', TType.I32, 2)
7340 
      oprot.writeI32(self.status)
7341 
      oprot.writeFieldEnd()
3431 rajveer 7342 
    if self.description is not None:
94 ashish 7343 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7344 
      oprot.writeString(self.description)
7345 
      oprot.writeFieldEnd()
7346 
    oprot.writeFieldStop()
7347 
    oprot.writeStructEnd()
7348 
 
3431 rajveer 7349 
  def validate(self):
7350 
    return
7351 
 
7352 
 
94 ashish 7353 
  def __repr__(self):
7354 
    L = ['%s=%r' % (key, value)
7355 
      for key, value in self.__dict__.iteritems()]
7356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7357 
 
7358 
  def __eq__(self, other):
7359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7360 
 
7361 
  def __ne__(self, other):
7362 
    return not (self == other)
7363 
 
7364 
class changeTransactionStatus_result:
7365 
  """
7366 
  Attributes:
7367 
   - success
7368 
   - ex
7369 
  """
7370 
 
7371 
  thrift_spec = (
7372 
    (0, TType.BOOL, 'success', None, None, ), # 0
7373 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7374 
  )
7375 
 
7376 
  def __init__(self, success=None, ex=None,):
7377 
    self.success = success
7378 
    self.ex = ex
7379 
 
7380 
  def read(self, iprot):
7381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7383 
      return
7384 
    iprot.readStructBegin()
7385 
    while True:
7386 
      (fname, ftype, fid) = iprot.readFieldBegin()
7387 
      if ftype == TType.STOP:
7388 
        break
7389 
      if fid == 0:
7390 
        if ftype == TType.BOOL:
7391 
          self.success = iprot.readBool();
7392 
        else:
7393 
          iprot.skip(ftype)
7394 
      elif fid == 1:
7395 
        if ftype == TType.STRUCT:
7396 
          self.ex = TransactionServiceException()
7397 
          self.ex.read(iprot)
7398 
        else:
7399 
          iprot.skip(ftype)
7400 
      else:
7401 
        iprot.skip(ftype)
7402 
      iprot.readFieldEnd()
7403 
    iprot.readStructEnd()
7404 
 
7405 
  def write(self, oprot):
7406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7408 
      return
7409 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 7410 
    if self.success is not None:
94 ashish 7411 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7412 
      oprot.writeBool(self.success)
7413 
      oprot.writeFieldEnd()
3431 rajveer 7414 
    if self.ex is not None:
94 ashish 7415 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7416 
      self.ex.write(oprot)
7417 
      oprot.writeFieldEnd()
7418 
    oprot.writeFieldStop()
7419 
    oprot.writeStructEnd()
7420 
 
3431 rajveer 7421 
  def validate(self):
7422 
    return
7423 
 
7424 
 
94 ashish 7425 
  def __repr__(self):
7426 
    L = ['%s=%r' % (key, value)
7427 
      for key, value in self.__dict__.iteritems()]
7428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7429 
 
7430 
  def __eq__(self, other):
7431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7432 
 
7433 
  def __ne__(self, other):
7434 
    return not (self == other)
7435 
 
1398 varun.gupt 7436 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 7437 
  """
7438 
  Attributes:
7439 
   - transactionId
7440 
  """
7441 
 
7442 
  thrift_spec = (
7443 
    None, # 0
7444 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7445 
  )
7446 
 
7447 
  def __init__(self, transactionId=None,):
7448 
    self.transactionId = transactionId
7449 
 
7450 
  def read(self, iprot):
7451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7453 
      return
7454 
    iprot.readStructBegin()
7455 
    while True:
7456 
      (fname, ftype, fid) = iprot.readFieldBegin()
7457 
      if ftype == TType.STOP:
7458 
        break
7459 
      if fid == 1:
7460 
        if ftype == TType.I64:
7461 
          self.transactionId = iprot.readI64();
7462 
        else:
7463 
          iprot.skip(ftype)
7464 
      else:
7465 
        iprot.skip(ftype)
7466 
      iprot.readFieldEnd()
7467 
    iprot.readStructEnd()
7468 
 
7469 
  def write(self, oprot):
7470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7472 
      return
1398 varun.gupt 7473 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 7474 
    if self.transactionId is not None:
1382 varun.gupt 7475 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7476 
      oprot.writeI64(self.transactionId)
7477 
      oprot.writeFieldEnd()
7478 
    oprot.writeFieldStop()
7479 
    oprot.writeStructEnd()
7480 
 
3431 rajveer 7481 
  def validate(self):
7482 
    return
7483 
 
7484 
 
1382 varun.gupt 7485 
  def __repr__(self):
7486 
    L = ['%s=%r' % (key, value)
7487 
      for key, value in self.__dict__.iteritems()]
7488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7489 
 
7490 
  def __eq__(self, other):
7491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7492 
 
7493 
  def __ne__(self, other):
7494 
    return not (self == other)
7495 
 
1398 varun.gupt 7496 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 7497 
  """
7498 
  Attributes:
7499 
   - success
7500 
   - ex
7501 
  """
7502 
 
7503 
  thrift_spec = (
7504 
    (0, TType.BOOL, 'success', None, None, ), # 0
7505 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7506 
  )
7507 
 
7508 
  def __init__(self, success=None, ex=None,):
7509 
    self.success = success
7510 
    self.ex = ex
7511 
 
7512 
  def read(self, iprot):
7513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7515 
      return
7516 
    iprot.readStructBegin()
7517 
    while True:
7518 
      (fname, ftype, fid) = iprot.readFieldBegin()
7519 
      if ftype == TType.STOP:
7520 
        break
7521 
      if fid == 0:
7522 
        if ftype == TType.BOOL:
7523 
          self.success = iprot.readBool();
7524 
        else:
7525 
          iprot.skip(ftype)
7526 
      elif fid == 1:
7527 
        if ftype == TType.STRUCT:
7528 
          self.ex = TransactionServiceException()
7529 
          self.ex.read(iprot)
7530 
        else:
7531 
          iprot.skip(ftype)
7532 
      else:
7533 
        iprot.skip(ftype)
7534 
      iprot.readFieldEnd()
7535 
    iprot.readStructEnd()
7536 
 
7537 
  def write(self, oprot):
7538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7540 
      return
1398 varun.gupt 7541 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 7542 
    if self.success is not None:
1382 varun.gupt 7543 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7544 
      oprot.writeBool(self.success)
7545 
      oprot.writeFieldEnd()
3431 rajveer 7546 
    if self.ex is not None:
1382 varun.gupt 7547 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7548 
      self.ex.write(oprot)
7549 
      oprot.writeFieldEnd()
7550 
    oprot.writeFieldStop()
7551 
    oprot.writeStructEnd()
7552 
 
3431 rajveer 7553 
  def validate(self):
7554 
    return
7555 
 
7556 
 
1382 varun.gupt 7557 
  def __repr__(self):
7558 
    L = ['%s=%r' % (key, value)
7559 
      for key, value in self.__dict__.iteritems()]
7560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7561 
 
7562 
  def __eq__(self, other):
7563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7564 
 
7565 
  def __ne__(self, other):
7566 
    return not (self == other)
7567 
 
483 rajveer 7568 
class getAllOrders_args:
94 ashish 7569 
  """
7570 
  Attributes:
4801 anupam.sin 7571 
   - statuses
483 rajveer 7572 
   - from_date
7573 
   - to_date
7574 
   - warehouse_id
94 ashish 7575 
  """
7576 
 
7577 
  thrift_spec = (
7578 
    None, # 0
4801 anupam.sin 7579 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 7580 
    (2, TType.I64, 'from_date', None, None, ), # 2
7581 
    (3, TType.I64, 'to_date', None, None, ), # 3
7582 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 7583 
  )
7584 
 
4801 anupam.sin 7585 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
7586 
    self.statuses = statuses
483 rajveer 7587 
    self.from_date = from_date
7588 
    self.to_date = to_date
7589 
    self.warehouse_id = warehouse_id
94 ashish 7590 
 
7591 
  def read(self, iprot):
7592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7594 
      return
7595 
    iprot.readStructBegin()
7596 
    while True:
7597 
      (fname, ftype, fid) = iprot.readFieldBegin()
7598 
      if ftype == TType.STOP:
7599 
        break
7600 
      if fid == 1:
4801 anupam.sin 7601 
        if ftype == TType.LIST:
7602 
          self.statuses = []
5031 varun.gupt 7603 
          (_etype80, _size77) = iprot.readListBegin()
7604 
          for _i81 in xrange(_size77):
7605 
            _elem82 = iprot.readI32();
7606 
            self.statuses.append(_elem82)
4801 anupam.sin 7607 
          iprot.readListEnd()
94 ashish 7608 
        else:
7609 
          iprot.skip(ftype)
483 rajveer 7610 
      elif fid == 2:
7611 
        if ftype == TType.I64:
7612 
          self.from_date = iprot.readI64();
94 ashish 7613 
        else:
7614 
          iprot.skip(ftype)
483 rajveer 7615 
      elif fid == 3:
7616 
        if ftype == TType.I64:
7617 
          self.to_date = iprot.readI64();
94 ashish 7618 
        else:
7619 
          iprot.skip(ftype)
483 rajveer 7620 
      elif fid == 4:
94 ashish 7621 
        if ftype == TType.I64:
483 rajveer 7622 
          self.warehouse_id = iprot.readI64();
94 ashish 7623 
        else:
7624 
          iprot.skip(ftype)
7625 
      else:
7626 
        iprot.skip(ftype)
7627 
      iprot.readFieldEnd()
7628 
    iprot.readStructEnd()
7629 
 
7630 
  def write(self, oprot):
7631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7633 
      return
483 rajveer 7634 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 7635 
    if self.statuses is not None:
7636 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7637 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7638 
      for iter83 in self.statuses:
7639 
        oprot.writeI32(iter83)
4801 anupam.sin 7640 
      oprot.writeListEnd()
94 ashish 7641 
      oprot.writeFieldEnd()
3431 rajveer 7642 
    if self.from_date is not None:
483 rajveer 7643 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7644 
      oprot.writeI64(self.from_date)
94 ashish 7645 
      oprot.writeFieldEnd()
3431 rajveer 7646 
    if self.to_date is not None:
483 rajveer 7647 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7648 
      oprot.writeI64(self.to_date)
94 ashish 7649 
      oprot.writeFieldEnd()
3431 rajveer 7650 
    if self.warehouse_id is not None:
483 rajveer 7651 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7652 
      oprot.writeI64(self.warehouse_id)
94 ashish 7653 
      oprot.writeFieldEnd()
7654 
    oprot.writeFieldStop()
7655 
    oprot.writeStructEnd()
7656 
 
3431 rajveer 7657 
  def validate(self):
7658 
    return
7659 
 
7660 
 
94 ashish 7661 
  def __repr__(self):
7662 
    L = ['%s=%r' % (key, value)
7663 
      for key, value in self.__dict__.iteritems()]
7664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7665 
 
7666 
  def __eq__(self, other):
7667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7668 
 
7669 
  def __ne__(self, other):
7670 
    return not (self == other)
7671 
 
483 rajveer 7672 
class getAllOrders_result:
94 ashish 7673 
  """
7674 
  Attributes:
7675 
   - success
7676 
   - ex
7677 
  """
7678 
 
7679 
  thrift_spec = (
483 rajveer 7680 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 7681 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7682 
  )
7683 
 
7684 
  def __init__(self, success=None, ex=None,):
7685 
    self.success = success
7686 
    self.ex = ex
7687 
 
7688 
  def read(self, iprot):
7689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7691 
      return
7692 
    iprot.readStructBegin()
7693 
    while True:
7694 
      (fname, ftype, fid) = iprot.readFieldBegin()
7695 
      if ftype == TType.STOP:
7696 
        break
7697 
      if fid == 0:
483 rajveer 7698 
        if ftype == TType.LIST:
7699 
          self.success = []
5031 varun.gupt 7700 
          (_etype87, _size84) = iprot.readListBegin()
7701 
          for _i88 in xrange(_size84):
7702 
            _elem89 = Order()
7703 
            _elem89.read(iprot)
7704 
            self.success.append(_elem89)
483 rajveer 7705 
          iprot.readListEnd()
94 ashish 7706 
        else:
7707 
          iprot.skip(ftype)
7708 
      elif fid == 1:
7709 
        if ftype == TType.STRUCT:
7710 
          self.ex = TransactionServiceException()
7711 
          self.ex.read(iprot)
7712 
        else:
7713 
          iprot.skip(ftype)
7714 
      else:
7715 
        iprot.skip(ftype)
7716 
      iprot.readFieldEnd()
7717 
    iprot.readStructEnd()
7718 
 
7719 
  def write(self, oprot):
7720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7722 
      return
483 rajveer 7723 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 7724 
    if self.success is not None:
483 rajveer 7725 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7726 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7727 
      for iter90 in self.success:
7728 
        iter90.write(oprot)
483 rajveer 7729 
      oprot.writeListEnd()
94 ashish 7730 
      oprot.writeFieldEnd()
3431 rajveer 7731 
    if self.ex is not None:
94 ashish 7732 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7733 
      self.ex.write(oprot)
7734 
      oprot.writeFieldEnd()
7735 
    oprot.writeFieldStop()
7736 
    oprot.writeStructEnd()
7737 
 
3431 rajveer 7738 
  def validate(self):
7739 
    return
7740 
 
7741 
 
94 ashish 7742 
  def __repr__(self):
7743 
    L = ['%s=%r' % (key, value)
7744 
      for key, value in self.__dict__.iteritems()]
7745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7746 
 
7747 
  def __eq__(self, other):
7748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7749 
 
7750 
  def __ne__(self, other):
7751 
    return not (self == other)
7752 
 
4133 chandransh 7753 
class getOrdersInBatch_args:
7754 
  """
7755 
  Attributes:
7756 
   - statuses
7757 
   - offset
7758 
   - limit
7759 
   - warehouse_id
7760 
  """
7761 
 
7762 
  thrift_spec = (
7763 
    None, # 0
7764 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7765 
    (2, TType.I64, 'offset', None, None, ), # 2
7766 
    (3, TType.I64, 'limit', None, None, ), # 3
7767 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7768 
  )
7769 
 
7770 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
7771 
    self.statuses = statuses
7772 
    self.offset = offset
7773 
    self.limit = limit
7774 
    self.warehouse_id = warehouse_id
7775 
 
7776 
  def read(self, iprot):
7777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7779 
      return
7780 
    iprot.readStructBegin()
7781 
    while True:
7782 
      (fname, ftype, fid) = iprot.readFieldBegin()
7783 
      if ftype == TType.STOP:
7784 
        break
7785 
      if fid == 1:
7786 
        if ftype == TType.LIST:
7787 
          self.statuses = []
5031 varun.gupt 7788 
          (_etype94, _size91) = iprot.readListBegin()
7789 
          for _i95 in xrange(_size91):
7790 
            _elem96 = iprot.readI32();
7791 
            self.statuses.append(_elem96)
4133 chandransh 7792 
          iprot.readListEnd()
7793 
        else:
7794 
          iprot.skip(ftype)
7795 
      elif fid == 2:
7796 
        if ftype == TType.I64:
7797 
          self.offset = iprot.readI64();
7798 
        else:
7799 
          iprot.skip(ftype)
7800 
      elif fid == 3:
7801 
        if ftype == TType.I64:
7802 
          self.limit = iprot.readI64();
7803 
        else:
7804 
          iprot.skip(ftype)
7805 
      elif fid == 4:
7806 
        if ftype == TType.I64:
7807 
          self.warehouse_id = iprot.readI64();
7808 
        else:
7809 
          iprot.skip(ftype)
7810 
      else:
7811 
        iprot.skip(ftype)
7812 
      iprot.readFieldEnd()
7813 
    iprot.readStructEnd()
7814 
 
7815 
  def write(self, oprot):
7816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7818 
      return
7819 
    oprot.writeStructBegin('getOrdersInBatch_args')
7820 
    if self.statuses is not None:
7821 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7822 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7823 
      for iter97 in self.statuses:
7824 
        oprot.writeI32(iter97)
4133 chandransh 7825 
      oprot.writeListEnd()
7826 
      oprot.writeFieldEnd()
7827 
    if self.offset is not None:
7828 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7829 
      oprot.writeI64(self.offset)
7830 
      oprot.writeFieldEnd()
7831 
    if self.limit is not None:
7832 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7833 
      oprot.writeI64(self.limit)
7834 
      oprot.writeFieldEnd()
7835 
    if self.warehouse_id is not None:
7836 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7837 
      oprot.writeI64(self.warehouse_id)
7838 
      oprot.writeFieldEnd()
7839 
    oprot.writeFieldStop()
7840 
    oprot.writeStructEnd()
7841 
 
7842 
  def validate(self):
7843 
    return
7844 
 
7845 
 
7846 
  def __repr__(self):
7847 
    L = ['%s=%r' % (key, value)
7848 
      for key, value in self.__dict__.iteritems()]
7849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7850 
 
7851 
  def __eq__(self, other):
7852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7853 
 
7854 
  def __ne__(self, other):
7855 
    return not (self == other)
7856 
 
7857 
class getOrdersInBatch_result:
7858 
  """
7859 
  Attributes:
7860 
   - success
7861 
   - ex
7862 
  """
7863 
 
7864 
  thrift_spec = (
7865 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7866 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7867 
  )
7868 
 
7869 
  def __init__(self, success=None, ex=None,):
7870 
    self.success = success
7871 
    self.ex = ex
7872 
 
7873 
  def read(self, iprot):
7874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7876 
      return
7877 
    iprot.readStructBegin()
7878 
    while True:
7879 
      (fname, ftype, fid) = iprot.readFieldBegin()
7880 
      if ftype == TType.STOP:
7881 
        break
7882 
      if fid == 0:
7883 
        if ftype == TType.LIST:
7884 
          self.success = []
5031 varun.gupt 7885 
          (_etype101, _size98) = iprot.readListBegin()
7886 
          for _i102 in xrange(_size98):
7887 
            _elem103 = Order()
7888 
            _elem103.read(iprot)
7889 
            self.success.append(_elem103)
4133 chandransh 7890 
          iprot.readListEnd()
7891 
        else:
7892 
          iprot.skip(ftype)
7893 
      elif fid == 1:
7894 
        if ftype == TType.STRUCT:
7895 
          self.ex = TransactionServiceException()
7896 
          self.ex.read(iprot)
7897 
        else:
7898 
          iprot.skip(ftype)
7899 
      else:
7900 
        iprot.skip(ftype)
7901 
      iprot.readFieldEnd()
7902 
    iprot.readStructEnd()
7903 
 
7904 
  def write(self, oprot):
7905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7907 
      return
7908 
    oprot.writeStructBegin('getOrdersInBatch_result')
7909 
    if self.success is not None:
7910 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7911 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7912 
      for iter104 in self.success:
7913 
        iter104.write(oprot)
4133 chandransh 7914 
      oprot.writeListEnd()
7915 
      oprot.writeFieldEnd()
7916 
    if self.ex is not None:
7917 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7918 
      self.ex.write(oprot)
7919 
      oprot.writeFieldEnd()
7920 
    oprot.writeFieldStop()
7921 
    oprot.writeStructEnd()
7922 
 
7923 
  def validate(self):
7924 
    return
7925 
 
7926 
 
7927 
  def __repr__(self):
7928 
    L = ['%s=%r' % (key, value)
7929 
      for key, value in self.__dict__.iteritems()]
7930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7931 
 
7932 
  def __eq__(self, other):
7933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7934 
 
7935 
  def __ne__(self, other):
7936 
    return not (self == other)
7937 
 
7938 
class getOrderCount_args:
7939 
  """
7940 
  Attributes:
7941 
   - statuses
7942 
   - warehouseId
7943 
  """
7944 
 
7945 
  thrift_spec = (
7946 
    None, # 0
7947 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7948 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7949 
  )
7950 
 
7951 
  def __init__(self, statuses=None, warehouseId=None,):
7952 
    self.statuses = statuses
7953 
    self.warehouseId = warehouseId
7954 
 
7955 
  def read(self, iprot):
7956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7958 
      return
7959 
    iprot.readStructBegin()
7960 
    while True:
7961 
      (fname, ftype, fid) = iprot.readFieldBegin()
7962 
      if ftype == TType.STOP:
7963 
        break
7964 
      if fid == 1:
7965 
        if ftype == TType.LIST:
7966 
          self.statuses = []
5031 varun.gupt 7967 
          (_etype108, _size105) = iprot.readListBegin()
7968 
          for _i109 in xrange(_size105):
7969 
            _elem110 = iprot.readI32();
7970 
            self.statuses.append(_elem110)
4133 chandransh 7971 
          iprot.readListEnd()
7972 
        else:
7973 
          iprot.skip(ftype)
7974 
      elif fid == 2:
7975 
        if ftype == TType.I64:
7976 
          self.warehouseId = iprot.readI64();
7977 
        else:
7978 
          iprot.skip(ftype)
7979 
      else:
7980 
        iprot.skip(ftype)
7981 
      iprot.readFieldEnd()
7982 
    iprot.readStructEnd()
7983 
 
7984 
  def write(self, oprot):
7985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7987 
      return
7988 
    oprot.writeStructBegin('getOrderCount_args')
7989 
    if self.statuses is not None:
7990 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7991 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7992 
      for iter111 in self.statuses:
7993 
        oprot.writeI32(iter111)
4133 chandransh 7994 
      oprot.writeListEnd()
7995 
      oprot.writeFieldEnd()
7996 
    if self.warehouseId is not None:
7997 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7998 
      oprot.writeI64(self.warehouseId)
7999 
      oprot.writeFieldEnd()
8000 
    oprot.writeFieldStop()
8001 
    oprot.writeStructEnd()
8002 
 
8003 
  def validate(self):
8004 
    return
8005 
 
8006 
 
8007 
  def __repr__(self):
8008 
    L = ['%s=%r' % (key, value)
8009 
      for key, value in self.__dict__.iteritems()]
8010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8011 
 
8012 
  def __eq__(self, other):
8013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8014 
 
8015 
  def __ne__(self, other):
8016 
    return not (self == other)
8017 
 
8018 
class getOrderCount_result:
8019 
  """
8020 
  Attributes:
8021 
   - success
8022 
   - ex
8023 
  """
8024 
 
8025 
  thrift_spec = (
8026 
    (0, TType.I32, 'success', None, None, ), # 0
8027 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8028 
  )
8029 
 
8030 
  def __init__(self, success=None, ex=None,):
8031 
    self.success = success
8032 
    self.ex = ex
8033 
 
8034 
  def read(self, iprot):
8035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8037 
      return
8038 
    iprot.readStructBegin()
8039 
    while True:
8040 
      (fname, ftype, fid) = iprot.readFieldBegin()
8041 
      if ftype == TType.STOP:
8042 
        break
8043 
      if fid == 0:
8044 
        if ftype == TType.I32:
8045 
          self.success = iprot.readI32();
8046 
        else:
8047 
          iprot.skip(ftype)
8048 
      elif fid == 1:
8049 
        if ftype == TType.STRUCT:
8050 
          self.ex = TransactionServiceException()
8051 
          self.ex.read(iprot)
8052 
        else:
8053 
          iprot.skip(ftype)
8054 
      else:
8055 
        iprot.skip(ftype)
8056 
      iprot.readFieldEnd()
8057 
    iprot.readStructEnd()
8058 
 
8059 
  def write(self, oprot):
8060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8062 
      return
8063 
    oprot.writeStructBegin('getOrderCount_result')
8064 
    if self.success is not None:
8065 
      oprot.writeFieldBegin('success', TType.I32, 0)
8066 
      oprot.writeI32(self.success)
8067 
      oprot.writeFieldEnd()
8068 
    if self.ex is not None:
8069 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8070 
      self.ex.write(oprot)
8071 
      oprot.writeFieldEnd()
8072 
    oprot.writeFieldStop()
8073 
    oprot.writeStructEnd()
8074 
 
8075 
  def validate(self):
8076 
    return
8077 
 
8078 
 
8079 
  def __repr__(self):
8080 
    L = ['%s=%r' % (key, value)
8081 
      for key, value in self.__dict__.iteritems()]
8082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8083 
 
8084 
  def __eq__(self, other):
8085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8086 
 
8087 
  def __ne__(self, other):
8088 
    return not (self == other)
8089 
 
999 varun.gupt 8090 
class getOrdersByBillingDate_args:
8091 
  """
8092 
  Attributes:
8093 
   - status
8094 
   - start_billing_date
8095 
   - end_billing_date
8096 
   - warehouse_id
8097 
  """
8098 
 
8099 
  thrift_spec = (
8100 
    None, # 0
8101 
    (1, TType.I32, 'status', None, None, ), # 1
8102 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
8103 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
8104 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8105 
  )
8106 
 
8107 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
8108 
    self.status = status
8109 
    self.start_billing_date = start_billing_date
8110 
    self.end_billing_date = end_billing_date
8111 
    self.warehouse_id = warehouse_id
8112 
 
8113 
  def read(self, iprot):
8114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8116 
      return
8117 
    iprot.readStructBegin()
8118 
    while True:
8119 
      (fname, ftype, fid) = iprot.readFieldBegin()
8120 
      if ftype == TType.STOP:
8121 
        break
8122 
      if fid == 1:
8123 
        if ftype == TType.I32:
8124 
          self.status = iprot.readI32();
8125 
        else:
8126 
          iprot.skip(ftype)
8127 
      elif fid == 2:
8128 
        if ftype == TType.I64:
8129 
          self.start_billing_date = iprot.readI64();
8130 
        else:
8131 
          iprot.skip(ftype)
8132 
      elif fid == 3:
8133 
        if ftype == TType.I64:
8134 
          self.end_billing_date = iprot.readI64();
8135 
        else:
8136 
          iprot.skip(ftype)
8137 
      elif fid == 4:
8138 
        if ftype == TType.I64:
8139 
          self.warehouse_id = iprot.readI64();
8140 
        else:
8141 
          iprot.skip(ftype)
8142 
      else:
8143 
        iprot.skip(ftype)
8144 
      iprot.readFieldEnd()
8145 
    iprot.readStructEnd()
8146 
 
8147 
  def write(self, oprot):
8148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8150 
      return
8151 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 8152 
    if self.status is not None:
999 varun.gupt 8153 
      oprot.writeFieldBegin('status', TType.I32, 1)
8154 
      oprot.writeI32(self.status)
8155 
      oprot.writeFieldEnd()
3431 rajveer 8156 
    if self.start_billing_date is not None:
999 varun.gupt 8157 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
8158 
      oprot.writeI64(self.start_billing_date)
8159 
      oprot.writeFieldEnd()
3431 rajveer 8160 
    if self.end_billing_date is not None:
999 varun.gupt 8161 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
8162 
      oprot.writeI64(self.end_billing_date)
8163 
      oprot.writeFieldEnd()
3431 rajveer 8164 
    if self.warehouse_id is not None:
999 varun.gupt 8165 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8166 
      oprot.writeI64(self.warehouse_id)
8167 
      oprot.writeFieldEnd()
8168 
    oprot.writeFieldStop()
8169 
    oprot.writeStructEnd()
8170 
 
3431 rajveer 8171 
  def validate(self):
8172 
    return
8173 
 
8174 
 
999 varun.gupt 8175 
  def __repr__(self):
8176 
    L = ['%s=%r' % (key, value)
8177 
      for key, value in self.__dict__.iteritems()]
8178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8179 
 
8180 
  def __eq__(self, other):
8181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8182 
 
8183 
  def __ne__(self, other):
8184 
    return not (self == other)
8185 
 
8186 
class getOrdersByBillingDate_result:
8187 
  """
8188 
  Attributes:
8189 
   - success
8190 
   - ex
8191 
  """
8192 
 
8193 
  thrift_spec = (
8194 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8195 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8196 
  )
8197 
 
8198 
  def __init__(self, success=None, ex=None,):
8199 
    self.success = success
8200 
    self.ex = ex
8201 
 
8202 
  def read(self, iprot):
8203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8205 
      return
8206 
    iprot.readStructBegin()
8207 
    while True:
8208 
      (fname, ftype, fid) = iprot.readFieldBegin()
8209 
      if ftype == TType.STOP:
8210 
        break
8211 
      if fid == 0:
8212 
        if ftype == TType.LIST:
8213 
          self.success = []
5031 varun.gupt 8214 
          (_etype115, _size112) = iprot.readListBegin()
8215 
          for _i116 in xrange(_size112):
8216 
            _elem117 = Order()
8217 
            _elem117.read(iprot)
8218 
            self.success.append(_elem117)
999 varun.gupt 8219 
          iprot.readListEnd()
8220 
        else:
8221 
          iprot.skip(ftype)
8222 
      elif fid == 1:
8223 
        if ftype == TType.STRUCT:
8224 
          self.ex = TransactionServiceException()
8225 
          self.ex.read(iprot)
8226 
        else:
8227 
          iprot.skip(ftype)
8228 
      else:
8229 
        iprot.skip(ftype)
8230 
      iprot.readFieldEnd()
8231 
    iprot.readStructEnd()
8232 
 
8233 
  def write(self, oprot):
8234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8236 
      return
8237 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 8238 
    if self.success is not None:
999 varun.gupt 8239 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8240 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8241 
      for iter118 in self.success:
8242 
        iter118.write(oprot)
999 varun.gupt 8243 
      oprot.writeListEnd()
8244 
      oprot.writeFieldEnd()
3431 rajveer 8245 
    if self.ex is not None:
999 varun.gupt 8246 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8247 
      self.ex.write(oprot)
8248 
      oprot.writeFieldEnd()
8249 
    oprot.writeFieldStop()
8250 
    oprot.writeStructEnd()
8251 
 
3431 rajveer 8252 
  def validate(self):
8253 
    return
8254 
 
8255 
 
999 varun.gupt 8256 
  def __repr__(self):
8257 
    L = ['%s=%r' % (key, value)
8258 
      for key, value in self.__dict__.iteritems()]
8259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8260 
 
8261 
  def __eq__(self, other):
8262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8263 
 
8264 
  def __ne__(self, other):
8265 
    return not (self == other)
8266 
 
3427 chandransh 8267 
class getOrdersByShippingDate_args:
8268 
  """
8269 
  Attributes:
8270 
   - fromShippingDate
8271 
   - toShippingDate
8272 
   - providerId
8273 
   - warehouseId
3451 chandransh 8274 
   - cod
3427 chandransh 8275 
  """
8276 
 
8277 
  thrift_spec = (
8278 
    None, # 0
8279 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
8280 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
8281 
    (3, TType.I64, 'providerId', None, None, ), # 3
8282 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 8283 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 8284 
  )
8285 
 
3451 chandransh 8286 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 8287 
    self.fromShippingDate = fromShippingDate
8288 
    self.toShippingDate = toShippingDate
8289 
    self.providerId = providerId
8290 
    self.warehouseId = warehouseId
3451 chandransh 8291 
    self.cod = cod
3427 chandransh 8292 
 
8293 
  def read(self, iprot):
8294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8296 
      return
8297 
    iprot.readStructBegin()
8298 
    while True:
8299 
      (fname, ftype, fid) = iprot.readFieldBegin()
8300 
      if ftype == TType.STOP:
8301 
        break
8302 
      if fid == 1:
8303 
        if ftype == TType.I64:
8304 
          self.fromShippingDate = iprot.readI64();
8305 
        else:
8306 
          iprot.skip(ftype)
8307 
      elif fid == 2:
8308 
        if ftype == TType.I64:
8309 
          self.toShippingDate = iprot.readI64();
8310 
        else:
8311 
          iprot.skip(ftype)
8312 
      elif fid == 3:
8313 
        if ftype == TType.I64:
8314 
          self.providerId = iprot.readI64();
8315 
        else:
8316 
          iprot.skip(ftype)
8317 
      elif fid == 4:
8318 
        if ftype == TType.I64:
8319 
          self.warehouseId = iprot.readI64();
8320 
        else:
8321 
          iprot.skip(ftype)
3451 chandransh 8322 
      elif fid == 5:
8323 
        if ftype == TType.BOOL:
8324 
          self.cod = iprot.readBool();
8325 
        else:
8326 
          iprot.skip(ftype)
3427 chandransh 8327 
      else:
8328 
        iprot.skip(ftype)
8329 
      iprot.readFieldEnd()
8330 
    iprot.readStructEnd()
8331 
 
8332 
  def write(self, oprot):
8333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8335 
      return
8336 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 8337 
    if self.fromShippingDate is not None:
3427 chandransh 8338 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
8339 
      oprot.writeI64(self.fromShippingDate)
8340 
      oprot.writeFieldEnd()
3431 rajveer 8341 
    if self.toShippingDate is not None:
3427 chandransh 8342 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
8343 
      oprot.writeI64(self.toShippingDate)
8344 
      oprot.writeFieldEnd()
3431 rajveer 8345 
    if self.providerId is not None:
3427 chandransh 8346 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
8347 
      oprot.writeI64(self.providerId)
8348 
      oprot.writeFieldEnd()
3431 rajveer 8349 
    if self.warehouseId is not None:
3427 chandransh 8350 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
8351 
      oprot.writeI64(self.warehouseId)
8352 
      oprot.writeFieldEnd()
3451 chandransh 8353 
    if self.cod is not None:
8354 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
8355 
      oprot.writeBool(self.cod)
8356 
      oprot.writeFieldEnd()
3427 chandransh 8357 
    oprot.writeFieldStop()
8358 
    oprot.writeStructEnd()
8359 
 
3431 rajveer 8360 
  def validate(self):
8361 
    return
8362 
 
8363 
 
3427 chandransh 8364 
  def __repr__(self):
8365 
    L = ['%s=%r' % (key, value)
8366 
      for key, value in self.__dict__.iteritems()]
8367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8368 
 
8369 
  def __eq__(self, other):
8370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8371 
 
8372 
  def __ne__(self, other):
8373 
    return not (self == other)
8374 
 
8375 
class getOrdersByShippingDate_result:
8376 
  """
8377 
  Attributes:
8378 
   - success
8379 
   - ex
8380 
  """
8381 
 
8382 
  thrift_spec = (
8383 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8384 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8385 
  )
8386 
 
8387 
  def __init__(self, success=None, ex=None,):
8388 
    self.success = success
8389 
    self.ex = ex
8390 
 
8391 
  def read(self, iprot):
8392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8394 
      return
8395 
    iprot.readStructBegin()
8396 
    while True:
8397 
      (fname, ftype, fid) = iprot.readFieldBegin()
8398 
      if ftype == TType.STOP:
8399 
        break
8400 
      if fid == 0:
8401 
        if ftype == TType.LIST:
8402 
          self.success = []
5031 varun.gupt 8403 
          (_etype122, _size119) = iprot.readListBegin()
8404 
          for _i123 in xrange(_size119):
8405 
            _elem124 = Order()
8406 
            _elem124.read(iprot)
8407 
            self.success.append(_elem124)
3427 chandransh 8408 
          iprot.readListEnd()
8409 
        else:
8410 
          iprot.skip(ftype)
8411 
      elif fid == 1:
8412 
        if ftype == TType.STRUCT:
8413 
          self.ex = TransactionServiceException()
8414 
          self.ex.read(iprot)
8415 
        else:
8416 
          iprot.skip(ftype)
8417 
      else:
8418 
        iprot.skip(ftype)
8419 
      iprot.readFieldEnd()
8420 
    iprot.readStructEnd()
8421 
 
8422 
  def write(self, oprot):
8423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8425 
      return
8426 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 8427 
    if self.success is not None:
3427 chandransh 8428 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8429 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8430 
      for iter125 in self.success:
8431 
        iter125.write(oprot)
3427 chandransh 8432 
      oprot.writeListEnd()
8433 
      oprot.writeFieldEnd()
3431 rajveer 8434 
    if self.ex is not None:
3427 chandransh 8435 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8436 
      self.ex.write(oprot)
8437 
      oprot.writeFieldEnd()
8438 
    oprot.writeFieldStop()
8439 
    oprot.writeStructEnd()
8440 
 
3431 rajveer 8441 
  def validate(self):
8442 
    return
8443 
 
8444 
 
3427 chandransh 8445 
  def __repr__(self):
8446 
    L = ['%s=%r' % (key, value)
8447 
      for key, value in self.__dict__.iteritems()]
8448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8449 
 
8450 
  def __eq__(self, other):
8451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8452 
 
8453 
  def __ne__(self, other):
8454 
    return not (self == other)
8455 
 
1382 varun.gupt 8456 
class getReturnableOrdersForCustomer_args:
8457 
  """
8458 
  Attributes:
8459 
   - customer_id
8460 
   - limit
8461 
  """
8462 
 
8463 
  thrift_spec = (
8464 
    None, # 0
8465 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8466 
    (2, TType.I64, 'limit', None, None, ), # 2
8467 
  )
8468 
 
8469 
  def __init__(self, customer_id=None, limit=None,):
8470 
    self.customer_id = customer_id
8471 
    self.limit = limit
8472 
 
8473 
  def read(self, iprot):
8474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8476 
      return
8477 
    iprot.readStructBegin()
8478 
    while True:
8479 
      (fname, ftype, fid) = iprot.readFieldBegin()
8480 
      if ftype == TType.STOP:
8481 
        break
8482 
      if fid == 1:
8483 
        if ftype == TType.I64:
8484 
          self.customer_id = iprot.readI64();
8485 
        else:
8486 
          iprot.skip(ftype)
8487 
      elif fid == 2:
8488 
        if ftype == TType.I64:
8489 
          self.limit = iprot.readI64();
8490 
        else:
8491 
          iprot.skip(ftype)
8492 
      else:
8493 
        iprot.skip(ftype)
8494 
      iprot.readFieldEnd()
8495 
    iprot.readStructEnd()
8496 
 
8497 
  def write(self, oprot):
8498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8500 
      return
8501 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 8502 
    if self.customer_id is not None:
1382 varun.gupt 8503 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8504 
      oprot.writeI64(self.customer_id)
8505 
      oprot.writeFieldEnd()
3431 rajveer 8506 
    if self.limit is not None:
1382 varun.gupt 8507 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8508 
      oprot.writeI64(self.limit)
8509 
      oprot.writeFieldEnd()
8510 
    oprot.writeFieldStop()
8511 
    oprot.writeStructEnd()
8512 
 
3431 rajveer 8513 
  def validate(self):
8514 
    return
8515 
 
8516 
 
1382 varun.gupt 8517 
  def __repr__(self):
8518 
    L = ['%s=%r' % (key, value)
8519 
      for key, value in self.__dict__.iteritems()]
8520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8521 
 
8522 
  def __eq__(self, other):
8523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8524 
 
8525 
  def __ne__(self, other):
8526 
    return not (self == other)
8527 
 
8528 
class getReturnableOrdersForCustomer_result:
8529 
  """
8530 
  Attributes:
8531 
   - success
8532 
   - ex
8533 
  """
8534 
 
8535 
  thrift_spec = (
8536 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8537 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8538 
  )
8539 
 
8540 
  def __init__(self, success=None, ex=None,):
8541 
    self.success = success
8542 
    self.ex = ex
8543 
 
8544 
  def read(self, iprot):
8545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8547 
      return
8548 
    iprot.readStructBegin()
8549 
    while True:
8550 
      (fname, ftype, fid) = iprot.readFieldBegin()
8551 
      if ftype == TType.STOP:
8552 
        break
8553 
      if fid == 0:
8554 
        if ftype == TType.LIST:
8555 
          self.success = []
5031 varun.gupt 8556 
          (_etype129, _size126) = iprot.readListBegin()
8557 
          for _i130 in xrange(_size126):
8558 
            _elem131 = iprot.readI64();
8559 
            self.success.append(_elem131)
1382 varun.gupt 8560 
          iprot.readListEnd()
8561 
        else:
8562 
          iprot.skip(ftype)
8563 
      elif fid == 1:
8564 
        if ftype == TType.STRUCT:
8565 
          self.ex = TransactionServiceException()
8566 
          self.ex.read(iprot)
8567 
        else:
8568 
          iprot.skip(ftype)
8569 
      else:
8570 
        iprot.skip(ftype)
8571 
      iprot.readFieldEnd()
8572 
    iprot.readStructEnd()
8573 
 
8574 
  def write(self, oprot):
8575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8577 
      return
8578 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 8579 
    if self.success is not None:
1382 varun.gupt 8580 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8581 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8582 
      for iter132 in self.success:
8583 
        oprot.writeI64(iter132)
1382 varun.gupt 8584 
      oprot.writeListEnd()
8585 
      oprot.writeFieldEnd()
3431 rajveer 8586 
    if self.ex is not None:
1382 varun.gupt 8587 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8588 
      self.ex.write(oprot)
8589 
      oprot.writeFieldEnd()
8590 
    oprot.writeFieldStop()
8591 
    oprot.writeStructEnd()
8592 
 
3431 rajveer 8593 
  def validate(self):
8594 
    return
8595 
 
8596 
 
1382 varun.gupt 8597 
  def __repr__(self):
8598 
    L = ['%s=%r' % (key, value)
8599 
      for key, value in self.__dict__.iteritems()]
8600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8601 
 
8602 
  def __eq__(self, other):
8603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8604 
 
8605 
  def __ne__(self, other):
8606 
    return not (self == other)
8607 
 
8608 
class getCancellableOrdersForCustomer_args:
8609 
  """
8610 
  Attributes:
8611 
   - customer_id
8612 
   - limit
8613 
  """
8614 
 
8615 
  thrift_spec = (
8616 
    None, # 0
8617 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8618 
    (2, TType.I64, 'limit', None, None, ), # 2
8619 
  )
8620 
 
8621 
  def __init__(self, customer_id=None, limit=None,):
8622 
    self.customer_id = customer_id
8623 
    self.limit = limit
8624 
 
8625 
  def read(self, iprot):
8626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8628 
      return
8629 
    iprot.readStructBegin()
8630 
    while True:
8631 
      (fname, ftype, fid) = iprot.readFieldBegin()
8632 
      if ftype == TType.STOP:
8633 
        break
8634 
      if fid == 1:
8635 
        if ftype == TType.I64:
8636 
          self.customer_id = iprot.readI64();
8637 
        else:
8638 
          iprot.skip(ftype)
8639 
      elif fid == 2:
8640 
        if ftype == TType.I64:
8641 
          self.limit = iprot.readI64();
8642 
        else:
8643 
          iprot.skip(ftype)
8644 
      else:
8645 
        iprot.skip(ftype)
8646 
      iprot.readFieldEnd()
8647 
    iprot.readStructEnd()
8648 
 
8649 
  def write(self, oprot):
8650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8652 
      return
8653 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 8654 
    if self.customer_id is not None:
1382 varun.gupt 8655 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8656 
      oprot.writeI64(self.customer_id)
8657 
      oprot.writeFieldEnd()
3431 rajveer 8658 
    if self.limit is not None:
1382 varun.gupt 8659 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8660 
      oprot.writeI64(self.limit)
8661 
      oprot.writeFieldEnd()
8662 
    oprot.writeFieldStop()
8663 
    oprot.writeStructEnd()
8664 
 
3431 rajveer 8665 
  def validate(self):
8666 
    return
8667 
 
8668 
 
1382 varun.gupt 8669 
  def __repr__(self):
8670 
    L = ['%s=%r' % (key, value)
8671 
      for key, value in self.__dict__.iteritems()]
8672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8673 
 
8674 
  def __eq__(self, other):
8675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8676 
 
8677 
  def __ne__(self, other):
8678 
    return not (self == other)
8679 
 
8680 
class getCancellableOrdersForCustomer_result:
8681 
  """
8682 
  Attributes:
8683 
   - success
8684 
   - ex
8685 
  """
8686 
 
8687 
  thrift_spec = (
8688 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8689 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8690 
  )
8691 
 
8692 
  def __init__(self, success=None, ex=None,):
8693 
    self.success = success
8694 
    self.ex = ex
8695 
 
8696 
  def read(self, iprot):
8697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8699 
      return
8700 
    iprot.readStructBegin()
8701 
    while True:
8702 
      (fname, ftype, fid) = iprot.readFieldBegin()
8703 
      if ftype == TType.STOP:
8704 
        break
8705 
      if fid == 0:
8706 
        if ftype == TType.LIST:
8707 
          self.success = []
5031 varun.gupt 8708 
          (_etype136, _size133) = iprot.readListBegin()
8709 
          for _i137 in xrange(_size133):
8710 
            _elem138 = iprot.readI64();
8711 
            self.success.append(_elem138)
1382 varun.gupt 8712 
          iprot.readListEnd()
8713 
        else:
8714 
          iprot.skip(ftype)
8715 
      elif fid == 1:
8716 
        if ftype == TType.STRUCT:
8717 
          self.ex = TransactionServiceException()
8718 
          self.ex.read(iprot)
8719 
        else:
8720 
          iprot.skip(ftype)
8721 
      else:
8722 
        iprot.skip(ftype)
8723 
      iprot.readFieldEnd()
8724 
    iprot.readStructEnd()
8725 
 
8726 
  def write(self, oprot):
8727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8729 
      return
8730 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 8731 
    if self.success is not None:
1382 varun.gupt 8732 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8733 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8734 
      for iter139 in self.success:
8735 
        oprot.writeI64(iter139)
1382 varun.gupt 8736 
      oprot.writeListEnd()
8737 
      oprot.writeFieldEnd()
3431 rajveer 8738 
    if self.ex is not None:
1382 varun.gupt 8739 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8740 
      self.ex.write(oprot)
8741 
      oprot.writeFieldEnd()
8742 
    oprot.writeFieldStop()
8743 
    oprot.writeStructEnd()
8744 
 
3431 rajveer 8745 
  def validate(self):
8746 
    return
8747 
 
8748 
 
1382 varun.gupt 8749 
  def __repr__(self):
8750 
    L = ['%s=%r' % (key, value)
8751 
      for key, value in self.__dict__.iteritems()]
8752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8753 
 
8754 
  def __eq__(self, other):
8755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8756 
 
8757 
  def __ne__(self, other):
8758 
    return not (self == other)
8759 
 
483 rajveer 8760 
class changeOrderStatus_args:
94 ashish 8761 
  """
8762 
  Attributes:
483 rajveer 8763 
   - orderId
8764 
   - status
8765 
   - description
94 ashish 8766 
  """
8767 
 
8768 
  thrift_spec = (
8769 
    None, # 0
483 rajveer 8770 
    (1, TType.I64, 'orderId', None, None, ), # 1
8771 
    (2, TType.I32, 'status', None, None, ), # 2
8772 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8773 
  )
8774 
 
483 rajveer 8775 
  def __init__(self, orderId=None, status=None, description=None,):
8776 
    self.orderId = orderId
8777 
    self.status = status
8778 
    self.description = description
94 ashish 8779 
 
8780 
  def read(self, iprot):
8781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8783 
      return
8784 
    iprot.readStructBegin()
8785 
    while True:
8786 
      (fname, ftype, fid) = iprot.readFieldBegin()
8787 
      if ftype == TType.STOP:
8788 
        break
8789 
      if fid == 1:
8790 
        if ftype == TType.I64:
483 rajveer 8791 
          self.orderId = iprot.readI64();
94 ashish 8792 
        else:
8793 
          iprot.skip(ftype)
8794 
      elif fid == 2:
483 rajveer 8795 
        if ftype == TType.I32:
8796 
          self.status = iprot.readI32();
94 ashish 8797 
        else:
8798 
          iprot.skip(ftype)
483 rajveer 8799 
      elif fid == 3:
8800 
        if ftype == TType.STRING:
8801 
          self.description = iprot.readString();
8802 
        else:
8803 
          iprot.skip(ftype)
94 ashish 8804 
      else:
8805 
        iprot.skip(ftype)
8806 
      iprot.readFieldEnd()
8807 
    iprot.readStructEnd()
8808 
 
8809 
  def write(self, oprot):
8810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8812 
      return
483 rajveer 8813 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 8814 
    if self.orderId is not None:
483 rajveer 8815 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8816 
      oprot.writeI64(self.orderId)
94 ashish 8817 
      oprot.writeFieldEnd()
3431 rajveer 8818 
    if self.status is not None:
483 rajveer 8819 
      oprot.writeFieldBegin('status', TType.I32, 2)
8820 
      oprot.writeI32(self.status)
94 ashish 8821 
      oprot.writeFieldEnd()
3431 rajveer 8822 
    if self.description is not None:
483 rajveer 8823 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8824 
      oprot.writeString(self.description)
8825 
      oprot.writeFieldEnd()
94 ashish 8826 
    oprot.writeFieldStop()
8827 
    oprot.writeStructEnd()
8828 
 
3431 rajveer 8829 
  def validate(self):
8830 
    return
8831 
 
8832 
 
94 ashish 8833 
  def __repr__(self):
8834 
    L = ['%s=%r' % (key, value)
8835 
      for key, value in self.__dict__.iteritems()]
8836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8837 
 
8838 
  def __eq__(self, other):
8839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8840 
 
8841 
  def __ne__(self, other):
8842 
    return not (self == other)
8843 
 
483 rajveer 8844 
class changeOrderStatus_result:
94 ashish 8845 
  """
8846 
  Attributes:
8847 
   - success
8848 
   - ex
8849 
  """
8850 
 
8851 
  thrift_spec = (
8852 
    (0, TType.BOOL, 'success', None, None, ), # 0
8853 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8854 
  )
8855 
 
8856 
  def __init__(self, success=None, ex=None,):
8857 
    self.success = success
8858 
    self.ex = ex
8859 
 
8860 
  def read(self, iprot):
8861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8863 
      return
8864 
    iprot.readStructBegin()
8865 
    while True:
8866 
      (fname, ftype, fid) = iprot.readFieldBegin()
8867 
      if ftype == TType.STOP:
8868 
        break
8869 
      if fid == 0:
8870 
        if ftype == TType.BOOL:
8871 
          self.success = iprot.readBool();
8872 
        else:
8873 
          iprot.skip(ftype)
8874 
      elif fid == 1:
8875 
        if ftype == TType.STRUCT:
8876 
          self.ex = TransactionServiceException()
8877 
          self.ex.read(iprot)
8878 
        else:
8879 
          iprot.skip(ftype)
8880 
      else:
8881 
        iprot.skip(ftype)
8882 
      iprot.readFieldEnd()
8883 
    iprot.readStructEnd()
8884 
 
8885 
  def write(self, oprot):
8886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8888 
      return
483 rajveer 8889 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 8890 
    if self.success is not None:
94 ashish 8891 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8892 
      oprot.writeBool(self.success)
8893 
      oprot.writeFieldEnd()
3431 rajveer 8894 
    if self.ex is not None:
94 ashish 8895 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8896 
      self.ex.write(oprot)
8897 
      oprot.writeFieldEnd()
8898 
    oprot.writeFieldStop()
8899 
    oprot.writeStructEnd()
8900 
 
3431 rajveer 8901 
  def validate(self):
8902 
    return
8903 
 
8904 
 
94 ashish 8905 
  def __repr__(self):
8906 
    L = ['%s=%r' % (key, value)
8907 
      for key, value in self.__dict__.iteritems()]
8908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8909 
 
8910 
  def __eq__(self, other):
8911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8912 
 
8913 
  def __ne__(self, other):
8914 
    return not (self == other)
8915 
 
3064 chandransh 8916 
class getOrdersForTransaction_args:
494 rajveer 8917 
  """
8918 
  Attributes:
3064 chandransh 8919 
   - transactionId
8920 
   - customerId
494 rajveer 8921 
  """
8922 
 
8923 
  thrift_spec = (
8924 
    None, # 0
3064 chandransh 8925 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8926 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 8927 
  )
8928 
 
3064 chandransh 8929 
  def __init__(self, transactionId=None, customerId=None,):
8930 
    self.transactionId = transactionId
8931 
    self.customerId = customerId
494 rajveer 8932 
 
8933 
  def read(self, iprot):
8934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8936 
      return
8937 
    iprot.readStructBegin()
8938 
    while True:
8939 
      (fname, ftype, fid) = iprot.readFieldBegin()
8940 
      if ftype == TType.STOP:
8941 
        break
8942 
      if fid == 1:
8943 
        if ftype == TType.I64:
3064 chandransh 8944 
          self.transactionId = iprot.readI64();
494 rajveer 8945 
        else:
8946 
          iprot.skip(ftype)
8947 
      elif fid == 2:
3064 chandransh 8948 
        if ftype == TType.I64:
8949 
          self.customerId = iprot.readI64();
494 rajveer 8950 
        else:
8951 
          iprot.skip(ftype)
8952 
      else:
8953 
        iprot.skip(ftype)
8954 
      iprot.readFieldEnd()
8955 
    iprot.readStructEnd()
8956 
 
8957 
  def write(self, oprot):
8958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8960 
      return
3064 chandransh 8961 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 8962 
    if self.transactionId is not None:
3064 chandransh 8963 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8964 
      oprot.writeI64(self.transactionId)
494 rajveer 8965 
      oprot.writeFieldEnd()
3431 rajveer 8966 
    if self.customerId is not None:
3064 chandransh 8967 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
8968 
      oprot.writeI64(self.customerId)
494 rajveer 8969 
      oprot.writeFieldEnd()
8970 
    oprot.writeFieldStop()
8971 
    oprot.writeStructEnd()
8972 
 
3431 rajveer 8973 
  def validate(self):
8974 
    return
8975 
 
8976 
 
494 rajveer 8977 
  def __repr__(self):
8978 
    L = ['%s=%r' % (key, value)
8979 
      for key, value in self.__dict__.iteritems()]
8980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8981 
 
8982 
  def __eq__(self, other):
8983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8984 
 
8985 
  def __ne__(self, other):
8986 
    return not (self == other)
8987 
 
3064 chandransh 8988 
class getOrdersForTransaction_result:
494 rajveer 8989 
  """
8990 
  Attributes:
8991 
   - success
8992 
   - ex
8993 
  """
8994 
 
8995 
  thrift_spec = (
3064 chandransh 8996 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 8997 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8998 
  )
8999 
 
9000 
  def __init__(self, success=None, ex=None,):
9001 
    self.success = success
9002 
    self.ex = ex
9003 
 
9004 
  def read(self, iprot):
9005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9007 
      return
9008 
    iprot.readStructBegin()
9009 
    while True:
9010 
      (fname, ftype, fid) = iprot.readFieldBegin()
9011 
      if ftype == TType.STOP:
9012 
        break
9013 
      if fid == 0:
3064 chandransh 9014 
        if ftype == TType.LIST:
9015 
          self.success = []
5031 varun.gupt 9016 
          (_etype143, _size140) = iprot.readListBegin()
9017 
          for _i144 in xrange(_size140):
9018 
            _elem145 = Order()
9019 
            _elem145.read(iprot)
9020 
            self.success.append(_elem145)
3064 chandransh 9021 
          iprot.readListEnd()
494 rajveer 9022 
        else:
9023 
          iprot.skip(ftype)
9024 
      elif fid == 1:
9025 
        if ftype == TType.STRUCT:
9026 
          self.ex = TransactionServiceException()
9027 
          self.ex.read(iprot)
9028 
        else:
9029 
          iprot.skip(ftype)
9030 
      else:
9031 
        iprot.skip(ftype)
9032 
      iprot.readFieldEnd()
9033 
    iprot.readStructEnd()
9034 
 
9035 
  def write(self, oprot):
9036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9038 
      return
3064 chandransh 9039 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 9040 
    if self.success is not None:
3064 chandransh 9041 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9042 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9043 
      for iter146 in self.success:
9044 
        iter146.write(oprot)
3064 chandransh 9045 
      oprot.writeListEnd()
494 rajveer 9046 
      oprot.writeFieldEnd()
3431 rajveer 9047 
    if self.ex is not None:
494 rajveer 9048 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9049 
      self.ex.write(oprot)
9050 
      oprot.writeFieldEnd()
9051 
    oprot.writeFieldStop()
9052 
    oprot.writeStructEnd()
9053 
 
3431 rajveer 9054 
  def validate(self):
9055 
    return
9056 
 
9057 
 
494 rajveer 9058 
  def __repr__(self):
9059 
    L = ['%s=%r' % (key, value)
9060 
      for key, value in self.__dict__.iteritems()]
9061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9062 
 
9063 
  def __eq__(self, other):
9064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9065 
 
9066 
  def __ne__(self, other):
9067 
    return not (self == other)
9068 
 
3064 chandransh 9069 
class getOrdersForCustomer_args:
1149 chandransh 9070 
  """
9071 
  Attributes:
3064 chandransh 9072 
   - customerId
9073 
   - from_date
9074 
   - to_date
9075 
   - statuses
1149 chandransh 9076 
  """
9077 
 
9078 
  thrift_spec = (
9079 
    None, # 0
3064 chandransh 9080 
    (1, TType.I64, 'customerId', None, None, ), # 1
9081 
    (2, TType.I64, 'from_date', None, None, ), # 2
9082 
    (3, TType.I64, 'to_date', None, None, ), # 3
9083 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 9084 
  )
9085 
 
3064 chandransh 9086 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
9087 
    self.customerId = customerId
9088 
    self.from_date = from_date
9089 
    self.to_date = to_date
9090 
    self.statuses = statuses
1149 chandransh 9091 
 
9092 
  def read(self, iprot):
9093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9095 
      return
9096 
    iprot.readStructBegin()
9097 
    while True:
9098 
      (fname, ftype, fid) = iprot.readFieldBegin()
9099 
      if ftype == TType.STOP:
9100 
        break
9101 
      if fid == 1:
9102 
        if ftype == TType.I64:
3064 chandransh 9103 
          self.customerId = iprot.readI64();
1149 chandransh 9104 
        else:
9105 
          iprot.skip(ftype)
9106 
      elif fid == 2:
9107 
        if ftype == TType.I64:
3064 chandransh 9108 
          self.from_date = iprot.readI64();
1149 chandransh 9109 
        else:
9110 
          iprot.skip(ftype)
2783 chandransh 9111 
      elif fid == 3:
9112 
        if ftype == TType.I64:
3064 chandransh 9113 
          self.to_date = iprot.readI64();
2783 chandransh 9114 
        else:
9115 
          iprot.skip(ftype)
9116 
      elif fid == 4:
3064 chandransh 9117 
        if ftype == TType.LIST:
9118 
          self.statuses = []
5031 varun.gupt 9119 
          (_etype150, _size147) = iprot.readListBegin()
9120 
          for _i151 in xrange(_size147):
9121 
            _elem152 = iprot.readI32();
9122 
            self.statuses.append(_elem152)
3064 chandransh 9123 
          iprot.readListEnd()
2783 chandransh 9124 
        else:
9125 
          iprot.skip(ftype)
1149 chandransh 9126 
      else:
9127 
        iprot.skip(ftype)
9128 
      iprot.readFieldEnd()
9129 
    iprot.readStructEnd()
9130 
 
9131 
  def write(self, oprot):
9132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9134 
      return
3064 chandransh 9135 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 9136 
    if self.customerId is not None:
3064 chandransh 9137 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9138 
      oprot.writeI64(self.customerId)
1149 chandransh 9139 
      oprot.writeFieldEnd()
3431 rajveer 9140 
    if self.from_date is not None:
3064 chandransh 9141 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9142 
      oprot.writeI64(self.from_date)
1149 chandransh 9143 
      oprot.writeFieldEnd()
3431 rajveer 9144 
    if self.to_date is not None:
3064 chandransh 9145 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9146 
      oprot.writeI64(self.to_date)
2783 chandransh 9147 
      oprot.writeFieldEnd()
3431 rajveer 9148 
    if self.statuses is not None:
3064 chandransh 9149 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
9150 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 9151 
      for iter153 in self.statuses:
9152 
        oprot.writeI32(iter153)
3064 chandransh 9153 
      oprot.writeListEnd()
2783 chandransh 9154 
      oprot.writeFieldEnd()
1149 chandransh 9155 
    oprot.writeFieldStop()
9156 
    oprot.writeStructEnd()
9157 
 
3431 rajveer 9158 
  def validate(self):
9159 
    return
9160 
 
9161 
 
1149 chandransh 9162 
  def __repr__(self):
9163 
    L = ['%s=%r' % (key, value)
9164 
      for key, value in self.__dict__.iteritems()]
9165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9166 
 
9167 
  def __eq__(self, other):
9168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9169 
 
9170 
  def __ne__(self, other):
9171 
    return not (self == other)
9172 
 
3064 chandransh 9173 
class getOrdersForCustomer_result:
1149 chandransh 9174 
  """
9175 
  Attributes:
9176 
   - success
9177 
   - ex
9178 
  """
9179 
 
9180 
  thrift_spec = (
3064 chandransh 9181 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 9182 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9183 
  )
9184 
 
9185 
  def __init__(self, success=None, ex=None,):
9186 
    self.success = success
9187 
    self.ex = ex
9188 
 
9189 
  def read(self, iprot):
9190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9192 
      return
9193 
    iprot.readStructBegin()
9194 
    while True:
9195 
      (fname, ftype, fid) = iprot.readFieldBegin()
9196 
      if ftype == TType.STOP:
9197 
        break
9198 
      if fid == 0:
3064 chandransh 9199 
        if ftype == TType.LIST:
9200 
          self.success = []
5031 varun.gupt 9201 
          (_etype157, _size154) = iprot.readListBegin()
9202 
          for _i158 in xrange(_size154):
9203 
            _elem159 = Order()
9204 
            _elem159.read(iprot)
9205 
            self.success.append(_elem159)
3064 chandransh 9206 
          iprot.readListEnd()
1149 chandransh 9207 
        else:
9208 
          iprot.skip(ftype)
9209 
      elif fid == 1:
9210 
        if ftype == TType.STRUCT:
9211 
          self.ex = TransactionServiceException()
9212 
          self.ex.read(iprot)
9213 
        else:
9214 
          iprot.skip(ftype)
9215 
      else:
9216 
        iprot.skip(ftype)
9217 
      iprot.readFieldEnd()
9218 
    iprot.readStructEnd()
9219 
 
9220 
  def write(self, oprot):
9221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9223 
      return
3064 chandransh 9224 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 9225 
    if self.success is not None:
3064 chandransh 9226 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9227 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9228 
      for iter160 in self.success:
9229 
        iter160.write(oprot)
3064 chandransh 9230 
      oprot.writeListEnd()
1149 chandransh 9231 
      oprot.writeFieldEnd()
3431 rajveer 9232 
    if self.ex is not None:
1149 chandransh 9233 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9234 
      self.ex.write(oprot)
9235 
      oprot.writeFieldEnd()
9236 
    oprot.writeFieldStop()
9237 
    oprot.writeStructEnd()
9238 
 
3431 rajveer 9239 
  def validate(self):
9240 
    return
9241 
 
9242 
 
1149 chandransh 9243 
  def __repr__(self):
9244 
    L = ['%s=%r' % (key, value)
9245 
      for key, value in self.__dict__.iteritems()]
9246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9247 
 
9248 
  def __eq__(self, other):
9249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9250 
 
9251 
  def __ne__(self, other):
9252 
    return not (self == other)
9253 
 
3064 chandransh 9254 
class createOrder_args:
921 rajveer 9255 
  """
9256 
  Attributes:
3064 chandransh 9257 
   - order
921 rajveer 9258 
  """
9259 
 
9260 
  thrift_spec = (
9261 
    None, # 0
3064 chandransh 9262 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 9263 
  )
9264 
 
3064 chandransh 9265 
  def __init__(self, order=None,):
9266 
    self.order = order
921 rajveer 9267 
 
9268 
  def read(self, iprot):
9269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9271 
      return
9272 
    iprot.readStructBegin()
9273 
    while True:
9274 
      (fname, ftype, fid) = iprot.readFieldBegin()
9275 
      if ftype == TType.STOP:
9276 
        break
9277 
      if fid == 1:
3064 chandransh 9278 
        if ftype == TType.STRUCT:
9279 
          self.order = Order()
9280 
          self.order.read(iprot)
921 rajveer 9281 
        else:
9282 
          iprot.skip(ftype)
9283 
      else:
9284 
        iprot.skip(ftype)
9285 
      iprot.readFieldEnd()
9286 
    iprot.readStructEnd()
9287 
 
9288 
  def write(self, oprot):
9289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9291 
      return
3064 chandransh 9292 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 9293 
    if self.order is not None:
3064 chandransh 9294 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
9295 
      self.order.write(oprot)
921 rajveer 9296 
      oprot.writeFieldEnd()
9297 
    oprot.writeFieldStop()
9298 
    oprot.writeStructEnd()
9299 
 
3431 rajveer 9300 
  def validate(self):
9301 
    return
9302 
 
9303 
 
921 rajveer 9304 
  def __repr__(self):
9305 
    L = ['%s=%r' % (key, value)
9306 
      for key, value in self.__dict__.iteritems()]
9307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9308 
 
9309 
  def __eq__(self, other):
9310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9311 
 
9312 
  def __ne__(self, other):
9313 
    return not (self == other)
9314 
 
3064 chandransh 9315 
class createOrder_result:
921 rajveer 9316 
  """
9317 
  Attributes:
9318 
   - success
9319 
   - ex
9320 
  """
9321 
 
9322 
  thrift_spec = (
3064 chandransh 9323 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 9324 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9325 
  )
9326 
 
9327 
  def __init__(self, success=None, ex=None,):
9328 
    self.success = success
9329 
    self.ex = ex
9330 
 
9331 
  def read(self, iprot):
9332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9334 
      return
9335 
    iprot.readStructBegin()
9336 
    while True:
9337 
      (fname, ftype, fid) = iprot.readFieldBegin()
9338 
      if ftype == TType.STOP:
9339 
        break
9340 
      if fid == 0:
3064 chandransh 9341 
        if ftype == TType.I64:
9342 
          self.success = iprot.readI64();
921 rajveer 9343 
        else:
9344 
          iprot.skip(ftype)
9345 
      elif fid == 1:
9346 
        if ftype == TType.STRUCT:
9347 
          self.ex = TransactionServiceException()
9348 
          self.ex.read(iprot)
9349 
        else:
9350 
          iprot.skip(ftype)
9351 
      else:
9352 
        iprot.skip(ftype)
9353 
      iprot.readFieldEnd()
9354 
    iprot.readStructEnd()
9355 
 
9356 
  def write(self, oprot):
9357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9359 
      return
3064 chandransh 9360 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 9361 
    if self.success is not None:
3064 chandransh 9362 
      oprot.writeFieldBegin('success', TType.I64, 0)
9363 
      oprot.writeI64(self.success)
921 rajveer 9364 
      oprot.writeFieldEnd()
3431 rajveer 9365 
    if self.ex is not None:
921 rajveer 9366 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9367 
      self.ex.write(oprot)
9368 
      oprot.writeFieldEnd()
9369 
    oprot.writeFieldStop()
9370 
    oprot.writeStructEnd()
9371 
 
3431 rajveer 9372 
  def validate(self):
9373 
    return
9374 
 
9375 
 
921 rajveer 9376 
  def __repr__(self):
9377 
    L = ['%s=%r' % (key, value)
9378 
      for key, value in self.__dict__.iteritems()]
9379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9380 
 
9381 
  def __eq__(self, other):
9382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9383 
 
9384 
  def __ne__(self, other):
9385 
    return not (self == other)
9386 
 
3064 chandransh 9387 
class getOrder_args:
921 rajveer 9388 
  """
9389 
  Attributes:
3064 chandransh 9390 
   - id
921 rajveer 9391 
  """
9392 
 
9393 
  thrift_spec = (
9394 
    None, # 0
3064 chandransh 9395 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 9396 
  )
9397 
 
3064 chandransh 9398 
  def __init__(self, id=None,):
9399 
    self.id = id
921 rajveer 9400 
 
9401 
  def read(self, iprot):
9402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9404 
      return
9405 
    iprot.readStructBegin()
9406 
    while True:
9407 
      (fname, ftype, fid) = iprot.readFieldBegin()
9408 
      if ftype == TType.STOP:
9409 
        break
9410 
      if fid == 1:
9411 
        if ftype == TType.I64:
3064 chandransh 9412 
          self.id = iprot.readI64();
921 rajveer 9413 
        else:
9414 
          iprot.skip(ftype)
9415 
      else:
9416 
        iprot.skip(ftype)
9417 
      iprot.readFieldEnd()
9418 
    iprot.readStructEnd()
9419 
 
9420 
  def write(self, oprot):
9421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9423 
      return
3064 chandransh 9424 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 9425 
    if self.id is not None:
3064 chandransh 9426 
      oprot.writeFieldBegin('id', TType.I64, 1)
9427 
      oprot.writeI64(self.id)
921 rajveer 9428 
      oprot.writeFieldEnd()
9429 
    oprot.writeFieldStop()
9430 
    oprot.writeStructEnd()
9431 
 
3431 rajveer 9432 
  def validate(self):
9433 
    return
9434 
 
9435 
 
921 rajveer 9436 
  def __repr__(self):
9437 
    L = ['%s=%r' % (key, value)
9438 
      for key, value in self.__dict__.iteritems()]
9439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9440 
 
9441 
  def __eq__(self, other):
9442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9443 
 
9444 
  def __ne__(self, other):
9445 
    return not (self == other)
9446 
 
3064 chandransh 9447 
class getOrder_result:
921 rajveer 9448 
  """
9449 
  Attributes:
9450 
   - success
9451 
   - ex
9452 
  """
9453 
 
9454 
  thrift_spec = (
3064 chandransh 9455 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 9456 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9457 
  )
9458 
 
9459 
  def __init__(self, success=None, ex=None,):
9460 
    self.success = success
9461 
    self.ex = ex
9462 
 
9463 
  def read(self, iprot):
9464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9466 
      return
9467 
    iprot.readStructBegin()
9468 
    while True:
9469 
      (fname, ftype, fid) = iprot.readFieldBegin()
9470 
      if ftype == TType.STOP:
9471 
        break
9472 
      if fid == 0:
3064 chandransh 9473 
        if ftype == TType.STRUCT:
9474 
          self.success = Order()
9475 
          self.success.read(iprot)
921 rajveer 9476 
        else:
9477 
          iprot.skip(ftype)
9478 
      elif fid == 1:
9479 
        if ftype == TType.STRUCT:
9480 
          self.ex = TransactionServiceException()
9481 
          self.ex.read(iprot)
9482 
        else:
9483 
          iprot.skip(ftype)
9484 
      else:
9485 
        iprot.skip(ftype)
9486 
      iprot.readFieldEnd()
9487 
    iprot.readStructEnd()
9488 
 
9489 
  def write(self, oprot):
9490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9492 
      return
3064 chandransh 9493 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 9494 
    if self.success is not None:
3064 chandransh 9495 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9496 
      self.success.write(oprot)
921 rajveer 9497 
      oprot.writeFieldEnd()
3431 rajveer 9498 
    if self.ex is not None:
921 rajveer 9499 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9500 
      self.ex.write(oprot)
9501 
      oprot.writeFieldEnd()
9502 
    oprot.writeFieldStop()
9503 
    oprot.writeStructEnd()
9504 
 
3431 rajveer 9505 
  def validate(self):
9506 
    return
9507 
 
9508 
 
921 rajveer 9509 
  def __repr__(self):
9510 
    L = ['%s=%r' % (key, value)
9511 
      for key, value in self.__dict__.iteritems()]
9512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9513 
 
9514 
  def __eq__(self, other):
9515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9516 
 
9517 
  def __ne__(self, other):
9518 
    return not (self == other)
9519 
 
3064 chandransh 9520 
class getLineItemsForOrder_args:
94 ashish 9521 
  """
9522 
  Attributes:
3064 chandransh 9523 
   - orderId
94 ashish 9524 
  """
9525 
 
9526 
  thrift_spec = (
9527 
    None, # 0
3064 chandransh 9528 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 9529 
  )
9530 
 
3064 chandransh 9531 
  def __init__(self, orderId=None,):
9532 
    self.orderId = orderId
94 ashish 9533 
 
9534 
  def read(self, iprot):
9535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9537 
      return
9538 
    iprot.readStructBegin()
9539 
    while True:
9540 
      (fname, ftype, fid) = iprot.readFieldBegin()
9541 
      if ftype == TType.STOP:
9542 
        break
9543 
      if fid == 1:
9544 
        if ftype == TType.I64:
3064 chandransh 9545 
          self.orderId = iprot.readI64();
94 ashish 9546 
        else:
9547 
          iprot.skip(ftype)
9548 
      else:
9549 
        iprot.skip(ftype)
9550 
      iprot.readFieldEnd()
9551 
    iprot.readStructEnd()
9552 
 
9553 
  def write(self, oprot):
9554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9556 
      return
3064 chandransh 9557 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 9558 
    if self.orderId is not None:
3064 chandransh 9559 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9560 
      oprot.writeI64(self.orderId)
94 ashish 9561 
      oprot.writeFieldEnd()
9562 
    oprot.writeFieldStop()
9563 
    oprot.writeStructEnd()
9564 
 
3431 rajveer 9565 
  def validate(self):
9566 
    return
9567 
 
9568 
 
94 ashish 9569 
  def __repr__(self):
9570 
    L = ['%s=%r' % (key, value)
9571 
      for key, value in self.__dict__.iteritems()]
9572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9573 
 
9574 
  def __eq__(self, other):
9575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9576 
 
9577 
  def __ne__(self, other):
9578 
    return not (self == other)
9579 
 
3064 chandransh 9580 
class getLineItemsForOrder_result:
94 ashish 9581 
  """
9582 
  Attributes:
9583 
   - success
9584 
   - ex
9585 
  """
9586 
 
9587 
  thrift_spec = (
3064 chandransh 9588 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 9589 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9590 
  )
9591 
 
9592 
  def __init__(self, success=None, ex=None,):
9593 
    self.success = success
9594 
    self.ex = ex
9595 
 
9596 
  def read(self, iprot):
9597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9599 
      return
9600 
    iprot.readStructBegin()
9601 
    while True:
9602 
      (fname, ftype, fid) = iprot.readFieldBegin()
9603 
      if ftype == TType.STOP:
9604 
        break
9605 
      if fid == 0:
483 rajveer 9606 
        if ftype == TType.LIST:
9607 
          self.success = []
5031 varun.gupt 9608 
          (_etype164, _size161) = iprot.readListBegin()
9609 
          for _i165 in xrange(_size161):
9610 
            _elem166 = LineItem()
9611 
            _elem166.read(iprot)
9612 
            self.success.append(_elem166)
483 rajveer 9613 
          iprot.readListEnd()
94 ashish 9614 
        else:
9615 
          iprot.skip(ftype)
9616 
      elif fid == 1:
9617 
        if ftype == TType.STRUCT:
9618 
          self.ex = TransactionServiceException()
9619 
          self.ex.read(iprot)
9620 
        else:
9621 
          iprot.skip(ftype)
9622 
      else:
9623 
        iprot.skip(ftype)
9624 
      iprot.readFieldEnd()
9625 
    iprot.readStructEnd()
9626 
 
9627 
  def write(self, oprot):
9628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9630 
      return
3064 chandransh 9631 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 9632 
    if self.success is not None:
483 rajveer 9633 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9634 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9635 
      for iter167 in self.success:
9636 
        iter167.write(oprot)
483 rajveer 9637 
      oprot.writeListEnd()
94 ashish 9638 
      oprot.writeFieldEnd()
3431 rajveer 9639 
    if self.ex is not None:
94 ashish 9640 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9641 
      self.ex.write(oprot)
9642 
      oprot.writeFieldEnd()
9643 
    oprot.writeFieldStop()
9644 
    oprot.writeStructEnd()
9645 
 
3431 rajveer 9646 
  def validate(self):
9647 
    return
9648 
 
9649 
 
94 ashish 9650 
  def __repr__(self):
9651 
    L = ['%s=%r' % (key, value)
9652 
      for key, value in self.__dict__.iteritems()]
9653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9654 
 
9655 
  def __eq__(self, other):
9656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9657 
 
9658 
  def __ne__(self, other):
9659 
    return not (self == other)
9660 
 
4999 phani.kuma 9661 
class getOrderList_args:
9662 
  """
9663 
  Attributes:
9664 
   - order_ids
9665 
  """
9666 
 
9667 
  thrift_spec = (
9668 
    None, # 0
9669 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
9670 
  )
9671 
 
9672 
  def __init__(self, order_ids=None,):
9673 
    self.order_ids = order_ids
9674 
 
9675 
  def read(self, iprot):
9676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9678 
      return
9679 
    iprot.readStructBegin()
9680 
    while True:
9681 
      (fname, ftype, fid) = iprot.readFieldBegin()
9682 
      if ftype == TType.STOP:
9683 
        break
9684 
      if fid == 1:
9685 
        if ftype == TType.LIST:
9686 
          self.order_ids = []
5031 varun.gupt 9687 
          (_etype171, _size168) = iprot.readListBegin()
9688 
          for _i172 in xrange(_size168):
9689 
            _elem173 = iprot.readI64();
9690 
            self.order_ids.append(_elem173)
4999 phani.kuma 9691 
          iprot.readListEnd()
9692 
        else:
9693 
          iprot.skip(ftype)
9694 
      else:
9695 
        iprot.skip(ftype)
9696 
      iprot.readFieldEnd()
9697 
    iprot.readStructEnd()
9698 
 
9699 
  def write(self, oprot):
9700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9702 
      return
9703 
    oprot.writeStructBegin('getOrderList_args')
9704 
    if self.order_ids is not None:
9705 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
9706 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
5031 varun.gupt 9707 
      for iter174 in self.order_ids:
9708 
        oprot.writeI64(iter174)
4999 phani.kuma 9709 
      oprot.writeListEnd()
9710 
      oprot.writeFieldEnd()
9711 
    oprot.writeFieldStop()
9712 
    oprot.writeStructEnd()
9713 
 
9714 
  def validate(self):
9715 
    return
9716 
 
9717 
 
9718 
  def __repr__(self):
9719 
    L = ['%s=%r' % (key, value)
9720 
      for key, value in self.__dict__.iteritems()]
9721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9722 
 
9723 
  def __eq__(self, other):
9724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9725 
 
9726 
  def __ne__(self, other):
9727 
    return not (self == other)
9728 
 
9729 
class getOrderList_result:
9730 
  """
9731 
  Attributes:
9732 
   - success
9733 
  """
9734 
 
9735 
  thrift_spec = (
9736 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9737 
  )
9738 
 
9739 
  def __init__(self, success=None,):
9740 
    self.success = success
9741 
 
9742 
  def read(self, iprot):
9743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9745 
      return
9746 
    iprot.readStructBegin()
9747 
    while True:
9748 
      (fname, ftype, fid) = iprot.readFieldBegin()
9749 
      if ftype == TType.STOP:
9750 
        break
9751 
      if fid == 0:
9752 
        if ftype == TType.LIST:
9753 
          self.success = []
5031 varun.gupt 9754 
          (_etype178, _size175) = iprot.readListBegin()
9755 
          for _i179 in xrange(_size175):
9756 
            _elem180 = Order()
9757 
            _elem180.read(iprot)
9758 
            self.success.append(_elem180)
4999 phani.kuma 9759 
          iprot.readListEnd()
9760 
        else:
9761 
          iprot.skip(ftype)
9762 
      else:
9763 
        iprot.skip(ftype)
9764 
      iprot.readFieldEnd()
9765 
    iprot.readStructEnd()
9766 
 
9767 
  def write(self, oprot):
9768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9770 
      return
9771 
    oprot.writeStructBegin('getOrderList_result')
9772 
    if self.success is not None:
9773 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9774 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9775 
      for iter181 in self.success:
9776 
        iter181.write(oprot)
4999 phani.kuma 9777 
      oprot.writeListEnd()
9778 
      oprot.writeFieldEnd()
9779 
    oprot.writeFieldStop()
9780 
    oprot.writeStructEnd()
9781 
 
9782 
  def validate(self):
9783 
    return
9784 
 
9785 
 
9786 
  def __repr__(self):
9787 
    L = ['%s=%r' % (key, value)
9788 
      for key, value in self.__dict__.iteritems()]
9789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9790 
 
9791 
  def __eq__(self, other):
9792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9793 
 
9794 
  def __ne__(self, other):
9795 
    return not (self == other)
9796 
 
3064 chandransh 9797 
class getOrderForCustomer_args:
94 ashish 9798 
  """
9799 
  Attributes:
3064 chandransh 9800 
   - orderId
483 rajveer 9801 
   - customerId
94 ashish 9802 
  """
9803 
 
9804 
  thrift_spec = (
9805 
    None, # 0
3064 chandransh 9806 
    (1, TType.I64, 'orderId', None, None, ), # 1
9807 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 9808 
  )
9809 
 
3064 chandransh 9810 
  def __init__(self, orderId=None, customerId=None,):
9811 
    self.orderId = orderId
483 rajveer 9812 
    self.customerId = customerId
94 ashish 9813 
 
9814 
  def read(self, iprot):
9815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9817 
      return
9818 
    iprot.readStructBegin()
9819 
    while True:
9820 
      (fname, ftype, fid) = iprot.readFieldBegin()
9821 
      if ftype == TType.STOP:
9822 
        break
9823 
      if fid == 1:
9824 
        if ftype == TType.I64:
3064 chandransh 9825 
          self.orderId = iprot.readI64();
94 ashish 9826 
        else:
9827 
          iprot.skip(ftype)
9828 
      elif fid == 2:
9829 
        if ftype == TType.I64:
3064 chandransh 9830 
          self.customerId = iprot.readI64();
94 ashish 9831 
        else:
9832 
          iprot.skip(ftype)
9833 
      else:
9834 
        iprot.skip(ftype)
9835 
      iprot.readFieldEnd()
9836 
    iprot.readStructEnd()
9837 
 
9838 
  def write(self, oprot):
9839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9841 
      return
3064 chandransh 9842 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 9843 
    if self.orderId is not None:
3064 chandransh 9844 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9845 
      oprot.writeI64(self.orderId)
9846 
      oprot.writeFieldEnd()
3431 rajveer 9847 
    if self.customerId is not None:
3064 chandransh 9848 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 9849 
      oprot.writeI64(self.customerId)
94 ashish 9850 
      oprot.writeFieldEnd()
9851 
    oprot.writeFieldStop()
9852 
    oprot.writeStructEnd()
9853 
 
3431 rajveer 9854 
  def validate(self):
9855 
    return
9856 
 
9857 
 
94 ashish 9858 
  def __repr__(self):
9859 
    L = ['%s=%r' % (key, value)
9860 
      for key, value in self.__dict__.iteritems()]
9861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9862 
 
9863 
  def __eq__(self, other):
9864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9865 
 
9866 
  def __ne__(self, other):
9867 
    return not (self == other)
9868 
 
3064 chandransh 9869 
class getOrderForCustomer_result:
94 ashish 9870 
  """
9871 
  Attributes:
9872 
   - success
9873 
   - ex
9874 
  """
9875 
 
9876 
  thrift_spec = (
3064 chandransh 9877 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 9878 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9879 
  )
9880 
 
9881 
  def __init__(self, success=None, ex=None,):
9882 
    self.success = success
9883 
    self.ex = ex
9884 
 
9885 
  def read(self, iprot):
9886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9888 
      return
9889 
    iprot.readStructBegin()
9890 
    while True:
9891 
      (fname, ftype, fid) = iprot.readFieldBegin()
9892 
      if ftype == TType.STOP:
9893 
        break
9894 
      if fid == 0:
3064 chandransh 9895 
        if ftype == TType.STRUCT:
9896 
          self.success = Order()
9897 
          self.success.read(iprot)
94 ashish 9898 
        else:
9899 
          iprot.skip(ftype)
9900 
      elif fid == 1:
9901 
        if ftype == TType.STRUCT:
9902 
          self.ex = TransactionServiceException()
9903 
          self.ex.read(iprot)
9904 
        else:
9905 
          iprot.skip(ftype)
9906 
      else:
9907 
        iprot.skip(ftype)
9908 
      iprot.readFieldEnd()
9909 
    iprot.readStructEnd()
9910 
 
9911 
  def write(self, oprot):
9912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9914 
      return
3064 chandransh 9915 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 9916 
    if self.success is not None:
3064 chandransh 9917 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9918 
      self.success.write(oprot)
94 ashish 9919 
      oprot.writeFieldEnd()
3431 rajveer 9920 
    if self.ex is not None:
94 ashish 9921 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9922 
      self.ex.write(oprot)
9923 
      oprot.writeFieldEnd()
9924 
    oprot.writeFieldStop()
9925 
    oprot.writeStructEnd()
9926 
 
3431 rajveer 9927 
  def validate(self):
9928 
    return
9929 
 
9930 
 
94 ashish 9931 
  def __repr__(self):
9932 
    L = ['%s=%r' % (key, value)
9933 
      for key, value in self.__dict__.iteritems()]
9934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9935 
 
9936 
  def __eq__(self, other):
9937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9938 
 
9939 
  def __ne__(self, other):
9940 
    return not (self == other)
9941 
 
3064 chandransh 9942 
class getAlerts_args:
94 ashish 9943 
  """
9944 
  Attributes:
4394 rajveer 9945 
   - type
4444 rajveer 9946 
   - warehouseId
4394 rajveer 9947 
   - status
9948 
   - timestamp
94 ashish 9949 
  """
9950 
 
9951 
  thrift_spec = (
9952 
    None, # 0
4394 rajveer 9953 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9954 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9955 
    (3, TType.I64, 'status', None, None, ), # 3
9956 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 9957 
  )
9958 
 
4444 rajveer 9959 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 9960 
    self.type = type
4444 rajveer 9961 
    self.warehouseId = warehouseId
4394 rajveer 9962 
    self.status = status
9963 
    self.timestamp = timestamp
94 ashish 9964 
 
9965 
  def read(self, iprot):
9966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9968 
      return
9969 
    iprot.readStructBegin()
9970 
    while True:
9971 
      (fname, ftype, fid) = iprot.readFieldBegin()
9972 
      if ftype == TType.STOP:
9973 
        break
9974 
      if fid == 1:
3064 chandransh 9975 
        if ftype == TType.I64:
4394 rajveer 9976 
          self.type = iprot.readI64();
94 ashish 9977 
        else:
9978 
          iprot.skip(ftype)
3064 chandransh 9979 
      elif fid == 2:
4394 rajveer 9980 
        if ftype == TType.I64:
4444 rajveer 9981 
          self.warehouseId = iprot.readI64();
3064 chandransh 9982 
        else:
9983 
          iprot.skip(ftype)
4394 rajveer 9984 
      elif fid == 3:
9985 
        if ftype == TType.I64:
4444 rajveer 9986 
          self.status = iprot.readI64();
9987 
        else:
9988 
          iprot.skip(ftype)
9989 
      elif fid == 4:
9990 
        if ftype == TType.I64:
4394 rajveer 9991 
          self.timestamp = iprot.readI64();
9992 
        else:
9993 
          iprot.skip(ftype)
94 ashish 9994 
      else:
9995 
        iprot.skip(ftype)
9996 
      iprot.readFieldEnd()
9997 
    iprot.readStructEnd()
9998 
 
9999 
  def write(self, oprot):
10000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10002 
      return
3064 chandransh 10003 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 10004 
    if self.type is not None:
10005 
      oprot.writeFieldBegin('type', TType.I64, 1)
10006 
      oprot.writeI64(self.type)
94 ashish 10007 
      oprot.writeFieldEnd()
4444 rajveer 10008 
    if self.warehouseId is not None:
10009 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10010 
      oprot.writeI64(self.warehouseId)
10011 
      oprot.writeFieldEnd()
4394 rajveer 10012 
    if self.status is not None:
4444 rajveer 10013 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 10014 
      oprot.writeI64(self.status)
3064 chandransh 10015 
      oprot.writeFieldEnd()
4394 rajveer 10016 
    if self.timestamp is not None:
4444 rajveer 10017 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 10018 
      oprot.writeI64(self.timestamp)
10019 
      oprot.writeFieldEnd()
94 ashish 10020 
    oprot.writeFieldStop()
10021 
    oprot.writeStructEnd()
10022 
 
3431 rajveer 10023 
  def validate(self):
10024 
    return
10025 
 
10026 
 
94 ashish 10027 
  def __repr__(self):
10028 
    L = ['%s=%r' % (key, value)
10029 
      for key, value in self.__dict__.iteritems()]
10030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10031 
 
10032 
  def __eq__(self, other):
10033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10034 
 
10035 
  def __ne__(self, other):
10036 
    return not (self == other)
10037 
 
3064 chandransh 10038 
class getAlerts_result:
94 ashish 10039 
  """
10040 
  Attributes:
10041 
   - success
10042 
  """
10043 
 
10044 
  thrift_spec = (
3064 chandransh 10045 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 10046 
  )
10047 
 
3064 chandransh 10048 
  def __init__(self, success=None,):
94 ashish 10049 
    self.success = success
10050 
 
10051 
  def read(self, iprot):
10052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10054 
      return
10055 
    iprot.readStructBegin()
10056 
    while True:
10057 
      (fname, ftype, fid) = iprot.readFieldBegin()
10058 
      if ftype == TType.STOP:
10059 
        break
10060 
      if fid == 0:
3064 chandransh 10061 
        if ftype == TType.LIST:
10062 
          self.success = []
5031 varun.gupt 10063 
          (_etype185, _size182) = iprot.readListBegin()
10064 
          for _i186 in xrange(_size182):
10065 
            _elem187 = Alert()
10066 
            _elem187.read(iprot)
10067 
            self.success.append(_elem187)
3064 chandransh 10068 
          iprot.readListEnd()
94 ashish 10069 
        else:
10070 
          iprot.skip(ftype)
10071 
      else:
10072 
        iprot.skip(ftype)
10073 
      iprot.readFieldEnd()
10074 
    iprot.readStructEnd()
10075 
 
10076 
  def write(self, oprot):
10077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10079 
      return
3064 chandransh 10080 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 10081 
    if self.success is not None:
3064 chandransh 10082 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10083 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10084 
      for iter188 in self.success:
10085 
        iter188.write(oprot)
3064 chandransh 10086 
      oprot.writeListEnd()
94 ashish 10087 
      oprot.writeFieldEnd()
10088 
    oprot.writeFieldStop()
10089 
    oprot.writeStructEnd()
10090 
 
3431 rajveer 10091 
  def validate(self):
10092 
    return
10093 
 
10094 
 
94 ashish 10095 
  def __repr__(self):
10096 
    L = ['%s=%r' % (key, value)
10097 
      for key, value in self.__dict__.iteritems()]
10098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10099 
 
10100 
  def __eq__(self, other):
10101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10102 
 
10103 
  def __ne__(self, other):
10104 
    return not (self == other)
10105 
 
4394 rajveer 10106 
class addAlert_args:
94 ashish 10107 
  """
10108 
  Attributes:
3064 chandransh 10109 
   - type
4444 rajveer 10110 
   - warehouseId
4394 rajveer 10111 
   - description
94 ashish 10112 
  """
10113 
 
10114 
  thrift_spec = (
10115 
    None, # 0
4394 rajveer 10116 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10117 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10118 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10119 
  )
10120 
 
4444 rajveer 10121 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 10122 
    self.type = type
4444 rajveer 10123 
    self.warehouseId = warehouseId
4394 rajveer 10124 
    self.description = description
94 ashish 10125 
 
10126 
  def read(self, iprot):
10127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10129 
      return
10130 
    iprot.readStructBegin()
10131 
    while True:
10132 
      (fname, ftype, fid) = iprot.readFieldBegin()
10133 
      if ftype == TType.STOP:
10134 
        break
10135 
      if fid == 1:
10136 
        if ftype == TType.I64:
4394 rajveer 10137 
          self.type = iprot.readI64();
94 ashish 10138 
        else:
10139 
          iprot.skip(ftype)
3064 chandransh 10140 
      elif fid == 2:
4444 rajveer 10141 
        if ftype == TType.I64:
10142 
          self.warehouseId = iprot.readI64();
10143 
        else:
10144 
          iprot.skip(ftype)
10145 
      elif fid == 3:
3064 chandransh 10146 
        if ftype == TType.STRING:
4394 rajveer 10147 
          self.description = iprot.readString();
3064 chandransh 10148 
        else:
10149 
          iprot.skip(ftype)
94 ashish 10150 
      else:
10151 
        iprot.skip(ftype)
10152 
      iprot.readFieldEnd()
10153 
    iprot.readStructEnd()
10154 
 
10155 
  def write(self, oprot):
10156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10158 
      return
4394 rajveer 10159 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 10160 
    if self.type is not None:
4394 rajveer 10161 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 10162 
      oprot.writeI64(self.type)
10163 
      oprot.writeFieldEnd()
4444 rajveer 10164 
    if self.warehouseId is not None:
10165 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10166 
      oprot.writeI64(self.warehouseId)
10167 
      oprot.writeFieldEnd()
4394 rajveer 10168 
    if self.description is not None:
4444 rajveer 10169 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 10170 
      oprot.writeString(self.description)
3064 chandransh 10171 
      oprot.writeFieldEnd()
94 ashish 10172 
    oprot.writeFieldStop()
10173 
    oprot.writeStructEnd()
10174 
 
3431 rajveer 10175 
  def validate(self):
10176 
    return
10177 
 
10178 
 
94 ashish 10179 
  def __repr__(self):
10180 
    L = ['%s=%r' % (key, value)
10181 
      for key, value in self.__dict__.iteritems()]
10182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10183 
 
10184 
  def __eq__(self, other):
10185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10186 
 
10187 
  def __ne__(self, other):
10188 
    return not (self == other)
10189 
 
4394 rajveer 10190 
class addAlert_result:
3064 chandransh 10191 
 
10192 
  thrift_spec = (
10193 
  )
10194 
 
10195 
  def read(self, iprot):
10196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10198 
      return
10199 
    iprot.readStructBegin()
10200 
    while True:
10201 
      (fname, ftype, fid) = iprot.readFieldBegin()
10202 
      if ftype == TType.STOP:
10203 
        break
10204 
      else:
10205 
        iprot.skip(ftype)
10206 
      iprot.readFieldEnd()
10207 
    iprot.readStructEnd()
10208 
 
10209 
  def write(self, oprot):
10210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10212 
      return
4394 rajveer 10213 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 10214 
    oprot.writeFieldStop()
10215 
    oprot.writeStructEnd()
10216 
 
3431 rajveer 10217 
  def validate(self):
10218 
    return
10219 
 
10220 
 
3064 chandransh 10221 
  def __repr__(self):
10222 
    L = ['%s=%r' % (key, value)
10223 
      for key, value in self.__dict__.iteritems()]
10224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10225 
 
10226 
  def __eq__(self, other):
10227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10228 
 
10229 
  def __ne__(self, other):
10230 
    return not (self == other)
10231 
 
4444 rajveer 10232 
class markAlertsAsSeen_args:
10233 
  """
10234 
  Attributes:
10235 
   - warehouseId
10236 
  """
10237 
 
10238 
  thrift_spec = (
10239 
    None, # 0
10240 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10241 
  )
10242 
 
10243 
  def __init__(self, warehouseId=None,):
10244 
    self.warehouseId = warehouseId
10245 
 
10246 
  def read(self, iprot):
10247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10249 
      return
10250 
    iprot.readStructBegin()
10251 
    while True:
10252 
      (fname, ftype, fid) = iprot.readFieldBegin()
10253 
      if ftype == TType.STOP:
10254 
        break
10255 
      if fid == 1:
10256 
        if ftype == TType.I64:
10257 
          self.warehouseId = iprot.readI64();
10258 
        else:
10259 
          iprot.skip(ftype)
10260 
      else:
10261 
        iprot.skip(ftype)
10262 
      iprot.readFieldEnd()
10263 
    iprot.readStructEnd()
10264 
 
10265 
  def write(self, oprot):
10266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10268 
      return
10269 
    oprot.writeStructBegin('markAlertsAsSeen_args')
10270 
    if self.warehouseId is not None:
10271 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10272 
      oprot.writeI64(self.warehouseId)
10273 
      oprot.writeFieldEnd()
10274 
    oprot.writeFieldStop()
10275 
    oprot.writeStructEnd()
10276 
 
10277 
  def validate(self):
10278 
    return
10279 
 
10280 
 
10281 
  def __repr__(self):
10282 
    L = ['%s=%r' % (key, value)
10283 
      for key, value in self.__dict__.iteritems()]
10284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10285 
 
10286 
  def __eq__(self, other):
10287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10288 
 
10289 
  def __ne__(self, other):
10290 
    return not (self == other)
10291 
 
10292 
class markAlertsAsSeen_result:
10293 
 
10294 
  thrift_spec = (
10295 
  )
10296 
 
10297 
  def read(self, iprot):
10298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10300 
      return
10301 
    iprot.readStructBegin()
10302 
    while True:
10303 
      (fname, ftype, fid) = iprot.readFieldBegin()
10304 
      if ftype == TType.STOP:
10305 
        break
10306 
      else:
10307 
        iprot.skip(ftype)
10308 
      iprot.readFieldEnd()
10309 
    iprot.readStructEnd()
10310 
 
10311 
  def write(self, oprot):
10312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10314 
      return
10315 
    oprot.writeStructBegin('markAlertsAsSeen_result')
10316 
    oprot.writeFieldStop()
10317 
    oprot.writeStructEnd()
10318 
 
10319 
  def validate(self):
10320 
    return
10321 
 
10322 
 
10323 
  def __repr__(self):
10324 
    L = ['%s=%r' % (key, value)
10325 
      for key, value in self.__dict__.iteritems()]
10326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10327 
 
10328 
  def __eq__(self, other):
10329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10330 
 
10331 
  def __ne__(self, other):
10332 
    return not (self == other)
10333 
 
3064 chandransh 10334 
class getValidOrderCount_args:
10335 
 
10336 
  thrift_spec = (
10337 
  )
10338 
 
10339 
  def read(self, iprot):
10340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10342 
      return
10343 
    iprot.readStructBegin()
10344 
    while True:
10345 
      (fname, ftype, fid) = iprot.readFieldBegin()
10346 
      if ftype == TType.STOP:
10347 
        break
10348 
      else:
10349 
        iprot.skip(ftype)
10350 
      iprot.readFieldEnd()
10351 
    iprot.readStructEnd()
10352 
 
10353 
  def write(self, oprot):
10354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10356 
      return
10357 
    oprot.writeStructBegin('getValidOrderCount_args')
10358 
    oprot.writeFieldStop()
10359 
    oprot.writeStructEnd()
10360 
 
3431 rajveer 10361 
  def validate(self):
10362 
    return
10363 
 
10364 
 
3064 chandransh 10365 
  def __repr__(self):
10366 
    L = ['%s=%r' % (key, value)
10367 
      for key, value in self.__dict__.iteritems()]
10368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10369 
 
10370 
  def __eq__(self, other):
10371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10372 
 
10373 
  def __ne__(self, other):
10374 
    return not (self == other)
10375 
 
10376 
class getValidOrderCount_result:
94 ashish 10377 
  """
10378 
  Attributes:
10379 
   - success
10380 
  """
10381 
 
10382 
  thrift_spec = (
3064 chandransh 10383 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10384 
  )
10385 
 
3064 chandransh 10386 
  def __init__(self, success=None,):
94 ashish 10387 
    self.success = success
10388 
 
10389 
  def read(self, iprot):
10390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10392 
      return
10393 
    iprot.readStructBegin()
10394 
    while True:
10395 
      (fname, ftype, fid) = iprot.readFieldBegin()
10396 
      if ftype == TType.STOP:
10397 
        break
10398 
      if fid == 0:
3064 chandransh 10399 
        if ftype == TType.I64:
10400 
          self.success = iprot.readI64();
94 ashish 10401 
        else:
10402 
          iprot.skip(ftype)
10403 
      else:
10404 
        iprot.skip(ftype)
10405 
      iprot.readFieldEnd()
10406 
    iprot.readStructEnd()
10407 
 
10408 
  def write(self, oprot):
10409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10411 
      return
3064 chandransh 10412 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 10413 
    if self.success is not None:
3064 chandransh 10414 
      oprot.writeFieldBegin('success', TType.I64, 0)
10415 
      oprot.writeI64(self.success)
94 ashish 10416 
      oprot.writeFieldEnd()
10417 
    oprot.writeFieldStop()
10418 
    oprot.writeStructEnd()
10419 
 
3431 rajveer 10420 
  def validate(self):
10421 
    return
10422 
 
10423 
 
94 ashish 10424 
  def __repr__(self):
10425 
    L = ['%s=%r' % (key, value)
10426 
      for key, value in self.__dict__.iteritems()]
10427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10428 
 
10429 
  def __eq__(self, other):
10430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10431 
 
10432 
  def __ne__(self, other):
10433 
    return not (self == other)
10434 
 
3064 chandransh 10435 
class getNoOfCustomersWithSuccessfulTransaction_args:
10436 
 
10437 
  thrift_spec = (
10438 
  )
10439 
 
10440 
  def read(self, iprot):
10441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10443 
      return
10444 
    iprot.readStructBegin()
10445 
    while True:
10446 
      (fname, ftype, fid) = iprot.readFieldBegin()
10447 
      if ftype == TType.STOP:
10448 
        break
10449 
      else:
10450 
        iprot.skip(ftype)
10451 
      iprot.readFieldEnd()
10452 
    iprot.readStructEnd()
10453 
 
10454 
  def write(self, oprot):
10455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10457 
      return
10458 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
10459 
    oprot.writeFieldStop()
10460 
    oprot.writeStructEnd()
10461 
 
3431 rajveer 10462 
  def validate(self):
10463 
    return
10464 
 
10465 
 
3064 chandransh 10466 
  def __repr__(self):
10467 
    L = ['%s=%r' % (key, value)
10468 
      for key, value in self.__dict__.iteritems()]
10469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10470 
 
10471 
  def __eq__(self, other):
10472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10473 
 
10474 
  def __ne__(self, other):
10475 
    return not (self == other)
10476 
 
10477 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 10478 
  """
10479 
  Attributes:
3064 chandransh 10480 
   - success
94 ashish 10481 
  """
10482 
 
10483 
  thrift_spec = (
3064 chandransh 10484 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10485 
  )
10486 
 
3064 chandransh 10487 
  def __init__(self, success=None,):
10488 
    self.success = success
94 ashish 10489 
 
10490 
  def read(self, iprot):
10491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10493 
      return
10494 
    iprot.readStructBegin()
10495 
    while True:
10496 
      (fname, ftype, fid) = iprot.readFieldBegin()
10497 
      if ftype == TType.STOP:
10498 
        break
3064 chandransh 10499 
      if fid == 0:
94 ashish 10500 
        if ftype == TType.I64:
3064 chandransh 10501 
          self.success = iprot.readI64();
94 ashish 10502 
        else:
10503 
          iprot.skip(ftype)
10504 
      else:
10505 
        iprot.skip(ftype)
10506 
      iprot.readFieldEnd()
10507 
    iprot.readStructEnd()
10508 
 
10509 
  def write(self, oprot):
10510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10512 
      return
3064 chandransh 10513 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 10514 
    if self.success is not None:
3064 chandransh 10515 
      oprot.writeFieldBegin('success', TType.I64, 0)
10516 
      oprot.writeI64(self.success)
94 ashish 10517 
      oprot.writeFieldEnd()
10518 
    oprot.writeFieldStop()
10519 
    oprot.writeStructEnd()
10520 
 
3431 rajveer 10521 
  def validate(self):
10522 
    return
10523 
 
10524 
 
94 ashish 10525 
  def __repr__(self):
10526 
    L = ['%s=%r' % (key, value)
10527 
      for key, value in self.__dict__.iteritems()]
10528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10529 
 
10530 
  def __eq__(self, other):
10531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10532 
 
10533 
  def __ne__(self, other):
10534 
    return not (self == other)
10535 
 
3064 chandransh 10536 
class getValidOrdersAmountRange_args:
10537 
 
10538 
  thrift_spec = (
10539 
  )
10540 
 
10541 
  def read(self, iprot):
10542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10544 
      return
10545 
    iprot.readStructBegin()
10546 
    while True:
10547 
      (fname, ftype, fid) = iprot.readFieldBegin()
10548 
      if ftype == TType.STOP:
10549 
        break
10550 
      else:
10551 
        iprot.skip(ftype)
10552 
      iprot.readFieldEnd()
10553 
    iprot.readStructEnd()
10554 
 
10555 
  def write(self, oprot):
10556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10558 
      return
10559 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
10560 
    oprot.writeFieldStop()
10561 
    oprot.writeStructEnd()
10562 
 
3431 rajveer 10563 
  def validate(self):
10564 
    return
10565 
 
10566 
 
3064 chandransh 10567 
  def __repr__(self):
10568 
    L = ['%s=%r' % (key, value)
10569 
      for key, value in self.__dict__.iteritems()]
10570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10571 
 
10572 
  def __eq__(self, other):
10573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10574 
 
10575 
  def __ne__(self, other):
10576 
    return not (self == other)
10577 
 
10578 
class getValidOrdersAmountRange_result:
94 ashish 10579 
  """
10580 
  Attributes:
10581 
   - success
10582 
  """
10583 
 
10584 
  thrift_spec = (
3064 chandransh 10585 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 10586 
  )
10587 
 
3064 chandransh 10588 
  def __init__(self, success=None,):
94 ashish 10589 
    self.success = success
10590 
 
10591 
  def read(self, iprot):
10592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10594 
      return
10595 
    iprot.readStructBegin()
10596 
    while True:
10597 
      (fname, ftype, fid) = iprot.readFieldBegin()
10598 
      if ftype == TType.STOP:
10599 
        break
10600 
      if fid == 0:
483 rajveer 10601 
        if ftype == TType.LIST:
10602 
          self.success = []
5031 varun.gupt 10603 
          (_etype192, _size189) = iprot.readListBegin()
10604 
          for _i193 in xrange(_size189):
10605 
            _elem194 = iprot.readDouble();
10606 
            self.success.append(_elem194)
483 rajveer 10607 
          iprot.readListEnd()
94 ashish 10608 
        else:
10609 
          iprot.skip(ftype)
10610 
      else:
10611 
        iprot.skip(ftype)
10612 
      iprot.readFieldEnd()
10613 
    iprot.readStructEnd()
10614 
 
10615 
  def write(self, oprot):
10616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10618 
      return
3064 chandransh 10619 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 10620 
    if self.success is not None:
483 rajveer 10621 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 10622 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
5031 varun.gupt 10623 
      for iter195 in self.success:
10624 
        oprot.writeDouble(iter195)
483 rajveer 10625 
      oprot.writeListEnd()
94 ashish 10626 
      oprot.writeFieldEnd()
10627 
    oprot.writeFieldStop()
10628 
    oprot.writeStructEnd()
10629 
 
3431 rajveer 10630 
  def validate(self):
10631 
    return
10632 
 
10633 
 
94 ashish 10634 
  def __repr__(self):
10635 
    L = ['%s=%r' % (key, value)
10636 
      for key, value in self.__dict__.iteritems()]
10637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10638 
 
10639 
  def __eq__(self, other):
10640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10641 
 
10642 
  def __ne__(self, other):
10643 
    return not (self == other)
10644 
 
3064 chandransh 10645 
class getValidOrders_args:
1528 ankur.sing 10646 
  """
10647 
  Attributes:
3064 chandransh 10648 
   - limit
1528 ankur.sing 10649 
  """
10650 
 
10651 
  thrift_spec = (
10652 
    None, # 0
3064 chandransh 10653 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 10654 
  )
10655 
 
3064 chandransh 10656 
  def __init__(self, limit=None,):
10657 
    self.limit = limit
1528 ankur.sing 10658 
 
10659 
  def read(self, iprot):
10660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10662 
      return
10663 
    iprot.readStructBegin()
10664 
    while True:
10665 
      (fname, ftype, fid) = iprot.readFieldBegin()
10666 
      if ftype == TType.STOP:
10667 
        break
10668 
      if fid == 1:
10669 
        if ftype == TType.I64:
3064 chandransh 10670 
          self.limit = iprot.readI64();
1528 ankur.sing 10671 
        else:
10672 
          iprot.skip(ftype)
10673 
      else:
10674 
        iprot.skip(ftype)
10675 
      iprot.readFieldEnd()
10676 
    iprot.readStructEnd()
10677 
 
10678 
  def write(self, oprot):
10679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10681 
      return
3064 chandransh 10682 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 10683 
    if self.limit is not None:
3064 chandransh 10684 
      oprot.writeFieldBegin('limit', TType.I64, 1)
10685 
      oprot.writeI64(self.limit)
1528 ankur.sing 10686 
      oprot.writeFieldEnd()
10687 
    oprot.writeFieldStop()
10688 
    oprot.writeStructEnd()
10689 
 
3431 rajveer 10690 
  def validate(self):
10691 
    return
10692 
 
10693 
 
1528 ankur.sing 10694 
  def __repr__(self):
10695 
    L = ['%s=%r' % (key, value)
10696 
      for key, value in self.__dict__.iteritems()]
10697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10698 
 
10699 
  def __eq__(self, other):
10700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10701 
 
10702 
  def __ne__(self, other):
10703 
    return not (self == other)
10704 
 
3064 chandransh 10705 
class getValidOrders_result:
1528 ankur.sing 10706 
  """
10707 
  Attributes:
10708 
   - success
10709 
  """
10710 
 
10711 
  thrift_spec = (
3064 chandransh 10712 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 10713 
  )
10714 
 
3064 chandransh 10715 
  def __init__(self, success=None,):
1528 ankur.sing 10716 
    self.success = success
10717 
 
10718 
  def read(self, iprot):
10719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10721 
      return
10722 
    iprot.readStructBegin()
10723 
    while True:
10724 
      (fname, ftype, fid) = iprot.readFieldBegin()
10725 
      if ftype == TType.STOP:
10726 
        break
10727 
      if fid == 0:
3064 chandransh 10728 
        if ftype == TType.LIST:
10729 
          self.success = []
5031 varun.gupt 10730 
          (_etype199, _size196) = iprot.readListBegin()
10731 
          for _i200 in xrange(_size196):
10732 
            _elem201 = Order()
10733 
            _elem201.read(iprot)
10734 
            self.success.append(_elem201)
3064 chandransh 10735 
          iprot.readListEnd()
1528 ankur.sing 10736 
        else:
10737 
          iprot.skip(ftype)
10738 
      else:
10739 
        iprot.skip(ftype)
10740 
      iprot.readFieldEnd()
10741 
    iprot.readStructEnd()
10742 
 
10743 
  def write(self, oprot):
10744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10746 
      return
3064 chandransh 10747 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 10748 
    if self.success is not None:
3064 chandransh 10749 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10750 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10751 
      for iter202 in self.success:
10752 
        iter202.write(oprot)
3064 chandransh 10753 
      oprot.writeListEnd()
1528 ankur.sing 10754 
      oprot.writeFieldEnd()
10755 
    oprot.writeFieldStop()
10756 
    oprot.writeStructEnd()
10757 
 
3431 rajveer 10758 
  def validate(self):
10759 
    return
10760 
 
10761 
 
1528 ankur.sing 10762 
  def __repr__(self):
10763 
    L = ['%s=%r' % (key, value)
10764 
      for key, value in self.__dict__.iteritems()]
10765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10766 
 
10767 
  def __eq__(self, other):
10768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10769 
 
10770 
  def __ne__(self, other):
10771 
    return not (self == other)
10772 
 
1220 chandransh 10773 
class batchOrders_args:
10774 
  """
10775 
  Attributes:
10776 
   - warehouseId
10777 
  """
10778 
 
10779 
  thrift_spec = (
10780 
    None, # 0
10781 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10782 
  )
10783 
 
10784 
  def __init__(self, warehouseId=None,):
10785 
    self.warehouseId = warehouseId
10786 
 
10787 
  def read(self, iprot):
10788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10790 
      return
10791 
    iprot.readStructBegin()
10792 
    while True:
10793 
      (fname, ftype, fid) = iprot.readFieldBegin()
10794 
      if ftype == TType.STOP:
10795 
        break
10796 
      if fid == 1:
10797 
        if ftype == TType.I64:
10798 
          self.warehouseId = iprot.readI64();
10799 
        else:
10800 
          iprot.skip(ftype)
10801 
      else:
10802 
        iprot.skip(ftype)
10803 
      iprot.readFieldEnd()
10804 
    iprot.readStructEnd()
10805 
 
10806 
  def write(self, oprot):
10807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10809 
      return
10810 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 10811 
    if self.warehouseId is not None:
1220 chandransh 10812 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10813 
      oprot.writeI64(self.warehouseId)
10814 
      oprot.writeFieldEnd()
10815 
    oprot.writeFieldStop()
10816 
    oprot.writeStructEnd()
10817 
 
3431 rajveer 10818 
  def validate(self):
10819 
    return
10820 
 
10821 
 
1220 chandransh 10822 
  def __repr__(self):
10823 
    L = ['%s=%r' % (key, value)
10824 
      for key, value in self.__dict__.iteritems()]
10825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10826 
 
10827 
  def __eq__(self, other):
10828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10829 
 
10830 
  def __ne__(self, other):
10831 
    return not (self == other)
10832 
 
10833 
class batchOrders_result:
10834 
  """
10835 
  Attributes:
10836 
   - success
10837 
   - ex
10838 
  """
10839 
 
10840 
  thrift_spec = (
10841 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10842 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10843 
  )
10844 
 
10845 
  def __init__(self, success=None, ex=None,):
10846 
    self.success = success
10847 
    self.ex = ex
10848 
 
10849 
  def read(self, iprot):
10850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10852 
      return
10853 
    iprot.readStructBegin()
10854 
    while True:
10855 
      (fname, ftype, fid) = iprot.readFieldBegin()
10856 
      if ftype == TType.STOP:
10857 
        break
10858 
      if fid == 0:
10859 
        if ftype == TType.LIST:
10860 
          self.success = []
5031 varun.gupt 10861 
          (_etype206, _size203) = iprot.readListBegin()
10862 
          for _i207 in xrange(_size203):
10863 
            _elem208 = Order()
10864 
            _elem208.read(iprot)
10865 
            self.success.append(_elem208)
1220 chandransh 10866 
          iprot.readListEnd()
10867 
        else:
10868 
          iprot.skip(ftype)
10869 
      elif fid == 1:
10870 
        if ftype == TType.STRUCT:
10871 
          self.ex = TransactionServiceException()
10872 
          self.ex.read(iprot)
10873 
        else:
10874 
          iprot.skip(ftype)
10875 
      else:
10876 
        iprot.skip(ftype)
10877 
      iprot.readFieldEnd()
10878 
    iprot.readStructEnd()
10879 
 
10880 
  def write(self, oprot):
10881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10883 
      return
10884 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 10885 
    if self.success is not None:
1220 chandransh 10886 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10887 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10888 
      for iter209 in self.success:
10889 
        iter209.write(oprot)
1220 chandransh 10890 
      oprot.writeListEnd()
10891 
      oprot.writeFieldEnd()
3431 rajveer 10892 
    if self.ex is not None:
1220 chandransh 10893 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10894 
      self.ex.write(oprot)
10895 
      oprot.writeFieldEnd()
10896 
    oprot.writeFieldStop()
10897 
    oprot.writeStructEnd()
10898 
 
3431 rajveer 10899 
  def validate(self):
10900 
    return
10901 
 
10902 
 
1220 chandransh 10903 
  def __repr__(self):
10904 
    L = ['%s=%r' % (key, value)
10905 
      for key, value in self.__dict__.iteritems()]
10906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10907 
 
10908 
  def __eq__(self, other):
10909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10910 
 
10911 
  def __ne__(self, other):
10912 
    return not (self == other)
10913 
 
1208 chandransh 10914 
class markOrderAsOutOfStock_args:
10915 
  """
10916 
  Attributes:
10917 
   - orderId
10918 
  """
10919 
 
10920 
  thrift_spec = (
10921 
    None, # 0
10922 
    (1, TType.I64, 'orderId', None, None, ), # 1
10923 
  )
10924 
 
10925 
  def __init__(self, orderId=None,):
10926 
    self.orderId = orderId
10927 
 
10928 
  def read(self, iprot):
10929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10931 
      return
10932 
    iprot.readStructBegin()
10933 
    while True:
10934 
      (fname, ftype, fid) = iprot.readFieldBegin()
10935 
      if ftype == TType.STOP:
10936 
        break
10937 
      if fid == 1:
10938 
        if ftype == TType.I64:
10939 
          self.orderId = iprot.readI64();
10940 
        else:
10941 
          iprot.skip(ftype)
10942 
      else:
10943 
        iprot.skip(ftype)
10944 
      iprot.readFieldEnd()
10945 
    iprot.readStructEnd()
10946 
 
10947 
  def write(self, oprot):
10948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10950 
      return
10951 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 10952 
    if self.orderId is not None:
1208 chandransh 10953 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10954 
      oprot.writeI64(self.orderId)
10955 
      oprot.writeFieldEnd()
10956 
    oprot.writeFieldStop()
10957 
    oprot.writeStructEnd()
10958 
 
3431 rajveer 10959 
  def validate(self):
10960 
    return
10961 
 
10962 
 
1208 chandransh 10963 
  def __repr__(self):
10964 
    L = ['%s=%r' % (key, value)
10965 
      for key, value in self.__dict__.iteritems()]
10966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10967 
 
10968 
  def __eq__(self, other):
10969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10970 
 
10971 
  def __ne__(self, other):
10972 
    return not (self == other)
10973 
 
10974 
class markOrderAsOutOfStock_result:
10975 
  """
10976 
  Attributes:
10977 
   - success
10978 
   - ex
10979 
  """
10980 
 
10981 
  thrift_spec = (
10982 
    (0, TType.BOOL, 'success', None, None, ), # 0
10983 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10984 
  )
10985 
 
10986 
  def __init__(self, success=None, ex=None,):
10987 
    self.success = success
10988 
    self.ex = ex
10989 
 
10990 
  def read(self, iprot):
10991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10993 
      return
10994 
    iprot.readStructBegin()
10995 
    while True:
10996 
      (fname, ftype, fid) = iprot.readFieldBegin()
10997 
      if ftype == TType.STOP:
10998 
        break
10999 
      if fid == 0:
11000 
        if ftype == TType.BOOL:
11001 
          self.success = iprot.readBool();
11002 
        else:
11003 
          iprot.skip(ftype)
11004 
      elif fid == 1:
11005 
        if ftype == TType.STRUCT:
11006 
          self.ex = TransactionServiceException()
11007 
          self.ex.read(iprot)
11008 
        else:
11009 
          iprot.skip(ftype)
11010 
      else:
11011 
        iprot.skip(ftype)
11012 
      iprot.readFieldEnd()
11013 
    iprot.readStructEnd()
11014 
 
11015 
  def write(self, oprot):
11016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11018 
      return
11019 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 11020 
    if self.success is not None:
1208 chandransh 11021 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11022 
      oprot.writeBool(self.success)
11023 
      oprot.writeFieldEnd()
3431 rajveer 11024 
    if self.ex is not None:
1208 chandransh 11025 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11026 
      self.ex.write(oprot)
11027 
      oprot.writeFieldEnd()
11028 
    oprot.writeFieldStop()
11029 
    oprot.writeStructEnd()
11030 
 
3431 rajveer 11031 
  def validate(self):
11032 
    return
11033 
 
11034 
 
1208 chandransh 11035 
  def __repr__(self):
11036 
    L = ['%s=%r' % (key, value)
11037 
      for key, value in self.__dict__.iteritems()]
11038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11039 
 
11040 
  def __eq__(self, other):
11041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11042 
 
11043 
  def __ne__(self, other):
11044 
    return not (self == other)
11045 
 
3064 chandransh 11046 
class verifyOrder_args:
759 chandransh 11047 
  """
11048 
  Attributes:
3064 chandransh 11049 
   - orderId
759 chandransh 11050 
  """
11051 
 
11052 
  thrift_spec = (
11053 
    None, # 0
3064 chandransh 11054 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 11055 
  )
11056 
 
3064 chandransh 11057 
  def __init__(self, orderId=None,):
11058 
    self.orderId = orderId
759 chandransh 11059 
 
11060 
  def read(self, iprot):
11061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11063 
      return
11064 
    iprot.readStructBegin()
11065 
    while True:
11066 
      (fname, ftype, fid) = iprot.readFieldBegin()
11067 
      if ftype == TType.STOP:
11068 
        break
11069 
      if fid == 1:
11070 
        if ftype == TType.I64:
3064 chandransh 11071 
          self.orderId = iprot.readI64();
759 chandransh 11072 
        else:
11073 
          iprot.skip(ftype)
11074 
      else:
11075 
        iprot.skip(ftype)
11076 
      iprot.readFieldEnd()
11077 
    iprot.readStructEnd()
11078 
 
11079 
  def write(self, oprot):
11080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11082 
      return
3064 chandransh 11083 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 11084 
    if self.orderId is not None:
3064 chandransh 11085 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11086 
      oprot.writeI64(self.orderId)
759 chandransh 11087 
      oprot.writeFieldEnd()
11088 
    oprot.writeFieldStop()
11089 
    oprot.writeStructEnd()
11090 
 
3431 rajveer 11091 
  def validate(self):
11092 
    return
11093 
 
11094 
 
759 chandransh 11095 
  def __repr__(self):
11096 
    L = ['%s=%r' % (key, value)
11097 
      for key, value in self.__dict__.iteritems()]
11098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11099 
 
11100 
  def __eq__(self, other):
11101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11102 
 
11103 
  def __ne__(self, other):
11104 
    return not (self == other)
11105 
 
3064 chandransh 11106 
class verifyOrder_result:
759 chandransh 11107 
  """
11108 
  Attributes:
11109 
   - success
11110 
   - ex
11111 
  """
11112 
 
11113 
  thrift_spec = (
11114 
    (0, TType.BOOL, 'success', None, None, ), # 0
11115 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11116 
  )
11117 
 
11118 
  def __init__(self, success=None, ex=None,):
11119 
    self.success = success
11120 
    self.ex = ex
11121 
 
11122 
  def read(self, iprot):
11123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11125 
      return
11126 
    iprot.readStructBegin()
11127 
    while True:
11128 
      (fname, ftype, fid) = iprot.readFieldBegin()
11129 
      if ftype == TType.STOP:
11130 
        break
11131 
      if fid == 0:
11132 
        if ftype == TType.BOOL:
11133 
          self.success = iprot.readBool();
11134 
        else:
11135 
          iprot.skip(ftype)
11136 
      elif fid == 1:
11137 
        if ftype == TType.STRUCT:
11138 
          self.ex = TransactionServiceException()
11139 
          self.ex.read(iprot)
11140 
        else:
11141 
          iprot.skip(ftype)
11142 
      else:
11143 
        iprot.skip(ftype)
11144 
      iprot.readFieldEnd()
11145 
    iprot.readStructEnd()
11146 
 
11147 
  def write(self, oprot):
11148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11150 
      return
3064 chandransh 11151 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 11152 
    if self.success is not None:
759 chandransh 11153 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11154 
      oprot.writeBool(self.success)
11155 
      oprot.writeFieldEnd()
3431 rajveer 11156 
    if self.ex is not None:
759 chandransh 11157 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11158 
      self.ex.write(oprot)
11159 
      oprot.writeFieldEnd()
11160 
    oprot.writeFieldStop()
11161 
    oprot.writeStructEnd()
11162 
 
3431 rajveer 11163 
  def validate(self):
11164 
    return
11165 
 
11166 
 
759 chandransh 11167 
  def __repr__(self):
11168 
    L = ['%s=%r' % (key, value)
11169 
      for key, value in self.__dict__.iteritems()]
11170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11171 
 
11172 
  def __eq__(self, other):
11173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11174 
 
11175 
  def __ne__(self, other):
11176 
    return not (self == other)
11177 
 
3064 chandransh 11178 
class acceptOrder_args:
1113 chandransh 11179 
  """
11180 
  Attributes:
3064 chandransh 11181 
   - orderId
1113 chandransh 11182 
  """
11183 
 
11184 
  thrift_spec = (
11185 
    None, # 0
3064 chandransh 11186 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 11187 
  )
11188 
 
3064 chandransh 11189 
  def __init__(self, orderId=None,):
11190 
    self.orderId = orderId
1113 chandransh 11191 
 
11192 
  def read(self, iprot):
11193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11195 
      return
11196 
    iprot.readStructBegin()
11197 
    while True:
11198 
      (fname, ftype, fid) = iprot.readFieldBegin()
11199 
      if ftype == TType.STOP:
11200 
        break
11201 
      if fid == 1:
11202 
        if ftype == TType.I64:
3064 chandransh 11203 
          self.orderId = iprot.readI64();
1113 chandransh 11204 
        else:
11205 
          iprot.skip(ftype)
11206 
      else:
11207 
        iprot.skip(ftype)
11208 
      iprot.readFieldEnd()
11209 
    iprot.readStructEnd()
11210 
 
11211 
  def write(self, oprot):
11212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11214 
      return
3064 chandransh 11215 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 11216 
    if self.orderId is not None:
3064 chandransh 11217 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11218 
      oprot.writeI64(self.orderId)
1113 chandransh 11219 
      oprot.writeFieldEnd()
11220 
    oprot.writeFieldStop()
11221 
    oprot.writeStructEnd()
11222 
 
3431 rajveer 11223 
  def validate(self):
11224 
    return
11225 
 
11226 
 
1113 chandransh 11227 
  def __repr__(self):
11228 
    L = ['%s=%r' % (key, value)
11229 
      for key, value in self.__dict__.iteritems()]
11230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11231 
 
11232 
  def __eq__(self, other):
11233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11234 
 
11235 
  def __ne__(self, other):
11236 
    return not (self == other)
11237 
 
3064 chandransh 11238 
class acceptOrder_result:
1113 chandransh 11239 
  """
11240 
  Attributes:
11241 
   - success
11242 
   - ex
11243 
  """
11244 
 
11245 
  thrift_spec = (
3064 chandransh 11246 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 11247 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11248 
  )
11249 
 
11250 
  def __init__(self, success=None, ex=None,):
11251 
    self.success = success
11252 
    self.ex = ex
11253 
 
11254 
  def read(self, iprot):
11255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11257 
      return
11258 
    iprot.readStructBegin()
11259 
    while True:
11260 
      (fname, ftype, fid) = iprot.readFieldBegin()
11261 
      if ftype == TType.STOP:
11262 
        break
11263 
      if fid == 0:
3064 chandransh 11264 
        if ftype == TType.BOOL:
11265 
          self.success = iprot.readBool();
1113 chandransh 11266 
        else:
11267 
          iprot.skip(ftype)
11268 
      elif fid == 1:
11269 
        if ftype == TType.STRUCT:
11270 
          self.ex = TransactionServiceException()
11271 
          self.ex.read(iprot)
11272 
        else:
11273 
          iprot.skip(ftype)
11274 
      else:
11275 
        iprot.skip(ftype)
11276 
      iprot.readFieldEnd()
11277 
    iprot.readStructEnd()
11278 
 
11279 
  def write(self, oprot):
11280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11282 
      return
3064 chandransh 11283 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 11284 
    if self.success is not None:
3064 chandransh 11285 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11286 
      oprot.writeBool(self.success)
1113 chandransh 11287 
      oprot.writeFieldEnd()
3431 rajveer 11288 
    if self.ex is not None:
1113 chandransh 11289 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11290 
      self.ex.write(oprot)
11291 
      oprot.writeFieldEnd()
11292 
    oprot.writeFieldStop()
11293 
    oprot.writeStructEnd()
11294 
 
3431 rajveer 11295 
  def validate(self):
11296 
    return
11297 
 
11298 
 
1113 chandransh 11299 
  def __repr__(self):
11300 
    L = ['%s=%r' % (key, value)
11301 
      for key, value in self.__dict__.iteritems()]
11302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11303 
 
11304 
  def __eq__(self, other):
11305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11306 
 
11307 
  def __ne__(self, other):
11308 
    return not (self == other)
11309 
 
3064 chandransh 11310 
class addBillingDetails_args:
1135 chandransh 11311 
  """
11312 
  Attributes:
3064 chandransh 11313 
   - orderId
11314 
   - invoice_number
4658 mandeep.dh 11315 
   - serialNumber
4283 anupam.sin 11316 
   - itemNumber
3064 chandransh 11317 
   - billed_by
4264 rajveer 11318 
   - jacketNumber
4283 anupam.sin 11319 
   - billingType
5110 mandeep.dh 11320 
   - fulfilmentWarehouseId
4763 rajveer 11321 
   - authorize
1135 chandransh 11322 
  """
11323 
 
11324 
  thrift_spec = (
11325 
    None, # 0
3064 chandransh 11326 
    (1, TType.I64, 'orderId', None, None, ), # 1
11327 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 11328 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 11329 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
11330 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
11331 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
11332 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 11333 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 11334 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 11335 
  )
11336 
 
5110 mandeep.dh 11337 
  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 11338 
    self.orderId = orderId
11339 
    self.invoice_number = invoice_number
4658 mandeep.dh 11340 
    self.serialNumber = serialNumber
4283 anupam.sin 11341 
    self.itemNumber = itemNumber
3064 chandransh 11342 
    self.billed_by = billed_by
4264 rajveer 11343 
    self.jacketNumber = jacketNumber
4283 anupam.sin 11344 
    self.billingType = billingType
5110 mandeep.dh 11345 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 11346 
    self.authorize = authorize
1135 chandransh 11347 
 
11348 
  def read(self, iprot):
11349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11351 
      return
11352 
    iprot.readStructBegin()
11353 
    while True:
11354 
      (fname, ftype, fid) = iprot.readFieldBegin()
11355 
      if ftype == TType.STOP:
11356 
        break
11357 
      if fid == 1:
11358 
        if ftype == TType.I64:
3064 chandransh 11359 
          self.orderId = iprot.readI64();
1135 chandransh 11360 
        else:
11361 
          iprot.skip(ftype)
11362 
      elif fid == 2:
3064 chandransh 11363 
        if ftype == TType.STRING:
11364 
          self.invoice_number = iprot.readString();
1135 chandransh 11365 
        else:
11366 
          iprot.skip(ftype)
3064 chandransh 11367 
      elif fid == 3:
4658 mandeep.dh 11368 
        if ftype == TType.STRING:
11369 
          self.serialNumber = iprot.readString();
3064 chandransh 11370 
        else:
11371 
          iprot.skip(ftype)
11372 
      elif fid == 4:
11373 
        if ftype == TType.STRING:
11374 
          self.itemNumber = iprot.readString();
11375 
        else:
11376 
          iprot.skip(ftype)
11377 
      elif fid == 5:
11378 
        if ftype == TType.STRING:
4283 anupam.sin 11379 
          self.billed_by = iprot.readString();
3064 chandransh 11380 
        else:
11381 
          iprot.skip(ftype)
11382 
      elif fid == 6:
11383 
        if ftype == TType.I64:
4283 anupam.sin 11384 
          self.jacketNumber = iprot.readI64();
11385 
        else:
11386 
          iprot.skip(ftype)
11387 
      elif fid == 7:
11388 
        if ftype == TType.I64:
3064 chandransh 11389 
          self.billingType = iprot.readI64();
11390 
        else:
11391 
          iprot.skip(ftype)
4283 anupam.sin 11392 
      elif fid == 8:
11393 
        if ftype == TType.I64:
5110 mandeep.dh 11394 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 11395 
        else:
11396 
          iprot.skip(ftype)
4763 rajveer 11397 
      elif fid == 9:
11398 
        if ftype == TType.BOOL:
11399 
          self.authorize = iprot.readBool();
11400 
        else:
11401 
          iprot.skip(ftype)
1246 chandransh 11402 
      else:
11403 
        iprot.skip(ftype)
11404 
      iprot.readFieldEnd()
11405 
    iprot.readStructEnd()
11406 
 
11407 
  def write(self, oprot):
11408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11410 
      return
4283 anupam.sin 11411 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 11412 
    if self.orderId is not None:
3064 chandransh 11413 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11414 
      oprot.writeI64(self.orderId)
1246 chandransh 11415 
      oprot.writeFieldEnd()
4283 anupam.sin 11416 
    if self.invoice_number is not None:
11417 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
11418 
      oprot.writeString(self.invoice_number)
1246 chandransh 11419 
      oprot.writeFieldEnd()
4658 mandeep.dh 11420 
    if self.serialNumber is not None:
11421 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
11422 
      oprot.writeString(self.serialNumber)
3064 chandransh 11423 
      oprot.writeFieldEnd()
3431 rajveer 11424 
    if self.itemNumber is not None:
3064 chandransh 11425 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
11426 
      oprot.writeString(self.itemNumber)
11427 
      oprot.writeFieldEnd()
4283 anupam.sin 11428 
    if self.billed_by is not None:
11429 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
11430 
      oprot.writeString(self.billed_by)
3064 chandransh 11431 
      oprot.writeFieldEnd()
4283 anupam.sin 11432 
    if self.jacketNumber is not None:
11433 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
11434 
      oprot.writeI64(self.jacketNumber)
11435 
      oprot.writeFieldEnd()
3431 rajveer 11436 
    if self.billingType is not None:
4283 anupam.sin 11437 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 11438 
      oprot.writeI64(self.billingType)
11439 
      oprot.writeFieldEnd()
5110 mandeep.dh 11440 
    if self.fulfilmentWarehouseId is not None:
11441 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
11442 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 11443 
      oprot.writeFieldEnd()
4763 rajveer 11444 
    if self.authorize is not None:
11445 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
11446 
      oprot.writeBool(self.authorize)
11447 
      oprot.writeFieldEnd()
1246 chandransh 11448 
    oprot.writeFieldStop()
11449 
    oprot.writeStructEnd()
11450 
 
3431 rajveer 11451 
  def validate(self):
11452 
    return
11453 
 
11454 
 
1246 chandransh 11455 
  def __repr__(self):
11456 
    L = ['%s=%r' % (key, value)
11457 
      for key, value in self.__dict__.iteritems()]
11458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11459 
 
11460 
  def __eq__(self, other):
11461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11462 
 
11463 
  def __ne__(self, other):
11464 
    return not (self == other)
11465 
 
4283 anupam.sin 11466 
class addBillingDetails_result:
1246 chandransh 11467 
  """
11468 
  Attributes:
3064 chandransh 11469 
   - success
1246 chandransh 11470 
   - ex
11471 
  """
11472 
 
11473 
  thrift_spec = (
3064 chandransh 11474 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 11475 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11476 
  )
11477 
 
3064 chandransh 11478 
  def __init__(self, success=None, ex=None,):
11479 
    self.success = success
1246 chandransh 11480 
    self.ex = ex
11481 
 
11482 
  def read(self, iprot):
11483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11485 
      return
11486 
    iprot.readStructBegin()
11487 
    while True:
11488 
      (fname, ftype, fid) = iprot.readFieldBegin()
11489 
      if ftype == TType.STOP:
11490 
        break
3064 chandransh 11491 
      if fid == 0:
11492 
        if ftype == TType.BOOL:
11493 
          self.success = iprot.readBool();
11494 
        else:
11495 
          iprot.skip(ftype)
11496 
      elif fid == 1:
1246 chandransh 11497 
        if ftype == TType.STRUCT:
11498 
          self.ex = TransactionServiceException()
11499 
          self.ex.read(iprot)
11500 
        else:
11501 
          iprot.skip(ftype)
11502 
      else:
11503 
        iprot.skip(ftype)
11504 
      iprot.readFieldEnd()
11505 
    iprot.readStructEnd()
11506 
 
11507 
  def write(self, oprot):
11508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11510 
      return
4283 anupam.sin 11511 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 11512 
    if self.success is not None:
3064 chandransh 11513 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11514 
      oprot.writeBool(self.success)
11515 
      oprot.writeFieldEnd()
3431 rajveer 11516 
    if self.ex is not None:
1246 chandransh 11517 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11518 
      self.ex.write(oprot)
11519 
      oprot.writeFieldEnd()
11520 
    oprot.writeFieldStop()
11521 
    oprot.writeStructEnd()
11522 
 
3431 rajveer 11523 
  def validate(self):
11524 
    return
11525 
 
11526 
 
1246 chandransh 11527 
  def __repr__(self):
11528 
    L = ['%s=%r' % (key, value)
11529 
      for key, value in self.__dict__.iteritems()]
11530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11531 
 
11532 
  def __eq__(self, other):
11533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11534 
 
11535 
  def __ne__(self, other):
11536 
    return not (self == other)
11537 
 
4579 rajveer 11538 
class addInvoiceNumber_args:
11539 
  """
11540 
  Attributes:
11541 
   - orderId
11542 
   - invoiceNumber
4763 rajveer 11543 
   - color
4579 rajveer 11544 
  """
11545 
 
11546 
  thrift_spec = (
11547 
    None, # 0
11548 
    (1, TType.I64, 'orderId', None, None, ), # 1
11549 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 11550 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 11551 
  )
11552 
 
4763 rajveer 11553 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 11554 
    self.orderId = orderId
11555 
    self.invoiceNumber = invoiceNumber
4763 rajveer 11556 
    self.color = color
4579 rajveer 11557 
 
11558 
  def read(self, iprot):
11559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11561 
      return
11562 
    iprot.readStructBegin()
11563 
    while True:
11564 
      (fname, ftype, fid) = iprot.readFieldBegin()
11565 
      if ftype == TType.STOP:
11566 
        break
11567 
      if fid == 1:
11568 
        if ftype == TType.I64:
11569 
          self.orderId = iprot.readI64();
11570 
        else:
11571 
          iprot.skip(ftype)
11572 
      elif fid == 2:
11573 
        if ftype == TType.STRING:
11574 
          self.invoiceNumber = iprot.readString();
11575 
        else:
11576 
          iprot.skip(ftype)
4763 rajveer 11577 
      elif fid == 3:
11578 
        if ftype == TType.STRING:
11579 
          self.color = iprot.readString();
11580 
        else:
11581 
          iprot.skip(ftype)
4579 rajveer 11582 
      else:
11583 
        iprot.skip(ftype)
11584 
      iprot.readFieldEnd()
11585 
    iprot.readStructEnd()
11586 
 
11587 
  def write(self, oprot):
11588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11590 
      return
11591 
    oprot.writeStructBegin('addInvoiceNumber_args')
11592 
    if self.orderId is not None:
11593 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11594 
      oprot.writeI64(self.orderId)
11595 
      oprot.writeFieldEnd()
11596 
    if self.invoiceNumber is not None:
11597 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
11598 
      oprot.writeString(self.invoiceNumber)
11599 
      oprot.writeFieldEnd()
4763 rajveer 11600 
    if self.color is not None:
11601 
      oprot.writeFieldBegin('color', TType.STRING, 3)
11602 
      oprot.writeString(self.color)
11603 
      oprot.writeFieldEnd()
4579 rajveer 11604 
    oprot.writeFieldStop()
11605 
    oprot.writeStructEnd()
11606 
 
11607 
  def validate(self):
11608 
    return
11609 
 
11610 
 
11611 
  def __repr__(self):
11612 
    L = ['%s=%r' % (key, value)
11613 
      for key, value in self.__dict__.iteritems()]
11614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11615 
 
11616 
  def __eq__(self, other):
11617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11618 
 
11619 
  def __ne__(self, other):
11620 
    return not (self == other)
11621 
 
11622 
class addInvoiceNumber_result:
11623 
  """
11624 
  Attributes:
11625 
   - ex
11626 
  """
11627 
 
11628 
  thrift_spec = (
11629 
    None, # 0
11630 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11631 
  )
11632 
 
11633 
  def __init__(self, ex=None,):
11634 
    self.ex = ex
11635 
 
11636 
  def read(self, iprot):
11637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11639 
      return
11640 
    iprot.readStructBegin()
11641 
    while True:
11642 
      (fname, ftype, fid) = iprot.readFieldBegin()
11643 
      if ftype == TType.STOP:
11644 
        break
11645 
      if fid == 1:
11646 
        if ftype == TType.STRUCT:
11647 
          self.ex = TransactionServiceException()
11648 
          self.ex.read(iprot)
11649 
        else:
11650 
          iprot.skip(ftype)
11651 
      else:
11652 
        iprot.skip(ftype)
11653 
      iprot.readFieldEnd()
11654 
    iprot.readStructEnd()
11655 
 
11656 
  def write(self, oprot):
11657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11659 
      return
11660 
    oprot.writeStructBegin('addInvoiceNumber_result')
11661 
    if self.ex is not None:
11662 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11663 
      self.ex.write(oprot)
11664 
      oprot.writeFieldEnd()
11665 
    oprot.writeFieldStop()
11666 
    oprot.writeStructEnd()
11667 
 
11668 
  def validate(self):
11669 
    return
11670 
 
11671 
 
11672 
  def __repr__(self):
11673 
    L = ['%s=%r' % (key, value)
11674 
      for key, value in self.__dict__.iteritems()]
11675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11676 
 
11677 
  def __eq__(self, other):
11678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11679 
 
11680 
  def __ne__(self, other):
11681 
    return not (self == other)
11682 
 
4910 phani.kuma 11683 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 11684 
  """
11685 
  Attributes:
3064 chandransh 11686 
   - warehouseId
1408 ankur.sing 11687 
   - providerId
3064 chandransh 11688 
   - cod
4910 phani.kuma 11689 
   - orderIds
1408 ankur.sing 11690 
  """
11691 
 
11692 
  thrift_spec = (
11693 
    None, # 0
3064 chandransh 11694 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11695 
    (2, TType.I64, 'providerId', None, None, ), # 2
11696 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 11697 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 11698 
  )
11699 
 
4910 phani.kuma 11700 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 11701 
    self.warehouseId = warehouseId
1408 ankur.sing 11702 
    self.providerId = providerId
3064 chandransh 11703 
    self.cod = cod
4910 phani.kuma 11704 
    self.orderIds = orderIds
1408 ankur.sing 11705 
 
11706 
  def read(self, iprot):
11707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11709 
      return
11710 
    iprot.readStructBegin()
11711 
    while True:
11712 
      (fname, ftype, fid) = iprot.readFieldBegin()
11713 
      if ftype == TType.STOP:
11714 
        break
11715 
      if fid == 1:
11716 
        if ftype == TType.I64:
3064 chandransh 11717 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 11718 
        else:
11719 
          iprot.skip(ftype)
11720 
      elif fid == 2:
11721 
        if ftype == TType.I64:
3064 chandransh 11722 
          self.providerId = iprot.readI64();
1408 ankur.sing 11723 
        else:
11724 
          iprot.skip(ftype)
3064 chandransh 11725 
      elif fid == 3:
11726 
        if ftype == TType.BOOL:
11727 
          self.cod = iprot.readBool();
11728 
        else:
11729 
          iprot.skip(ftype)
4910 phani.kuma 11730 
      elif fid == 4:
11731 
        if ftype == TType.LIST:
11732 
          self.orderIds = []
5031 varun.gupt 11733 
          (_etype213, _size210) = iprot.readListBegin()
11734 
          for _i214 in xrange(_size210):
11735 
            _elem215 = iprot.readI64();
11736 
            self.orderIds.append(_elem215)
4910 phani.kuma 11737 
          iprot.readListEnd()
11738 
        else:
11739 
          iprot.skip(ftype)
1408 ankur.sing 11740 
      else:
11741 
        iprot.skip(ftype)
11742 
      iprot.readFieldEnd()
11743 
    iprot.readStructEnd()
11744 
 
11745 
  def write(self, oprot):
11746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11748 
      return
4910 phani.kuma 11749 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 11750 
    if self.warehouseId is not None:
3064 chandransh 11751 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11752 
      oprot.writeI64(self.warehouseId)
11753 
      oprot.writeFieldEnd()
3431 rajveer 11754 
    if self.providerId is not None:
3064 chandransh 11755 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 11756 
      oprot.writeI64(self.providerId)
11757 
      oprot.writeFieldEnd()
3431 rajveer 11758 
    if self.cod is not None:
3064 chandransh 11759 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
11760 
      oprot.writeBool(self.cod)
1408 ankur.sing 11761 
      oprot.writeFieldEnd()
4910 phani.kuma 11762 
    if self.orderIds is not None:
11763 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
11764 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5031 varun.gupt 11765 
      for iter216 in self.orderIds:
11766 
        oprot.writeI64(iter216)
4910 phani.kuma 11767 
      oprot.writeListEnd()
11768 
      oprot.writeFieldEnd()
1408 ankur.sing 11769 
    oprot.writeFieldStop()
11770 
    oprot.writeStructEnd()
11771 
 
3431 rajveer 11772 
  def validate(self):
11773 
    return
11774 
 
11775 
 
1408 ankur.sing 11776 
  def __repr__(self):
11777 
    L = ['%s=%r' % (key, value)
11778 
      for key, value in self.__dict__.iteritems()]
11779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11780 
 
11781 
  def __eq__(self, other):
11782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11783 
 
11784 
  def __ne__(self, other):
11785 
    return not (self == other)
11786 
 
4910 phani.kuma 11787 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 11788 
  """
11789 
  Attributes:
11790 
   - success
3064 chandransh 11791 
   - ex
1408 ankur.sing 11792 
  """
11793 
 
11794 
  thrift_spec = (
3064 chandransh 11795 
    (0, TType.BOOL, 'success', None, None, ), # 0
11796 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 11797 
  )
11798 
 
3064 chandransh 11799 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 11800 
    self.success = success
3064 chandransh 11801 
    self.ex = ex
1408 ankur.sing 11802 
 
11803 
  def read(self, iprot):
11804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11806 
      return
11807 
    iprot.readStructBegin()
11808 
    while True:
11809 
      (fname, ftype, fid) = iprot.readFieldBegin()
11810 
      if ftype == TType.STOP:
11811 
        break
11812 
      if fid == 0:
3064 chandransh 11813 
        if ftype == TType.BOOL:
11814 
          self.success = iprot.readBool();
1408 ankur.sing 11815 
        else:
11816 
          iprot.skip(ftype)
3064 chandransh 11817 
      elif fid == 1:
11818 
        if ftype == TType.STRUCT:
11819 
          self.ex = TransactionServiceException()
11820 
          self.ex.read(iprot)
11821 
        else:
11822 
          iprot.skip(ftype)
1408 ankur.sing 11823 
      else:
11824 
        iprot.skip(ftype)
11825 
      iprot.readFieldEnd()
11826 
    iprot.readStructEnd()
11827 
 
11828 
  def write(self, oprot):
11829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11831 
      return
4910 phani.kuma 11832 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 11833 
    if self.success is not None:
3064 chandransh 11834 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11835 
      oprot.writeBool(self.success)
1408 ankur.sing 11836 
      oprot.writeFieldEnd()
3431 rajveer 11837 
    if self.ex is not None:
3064 chandransh 11838 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11839 
      self.ex.write(oprot)
11840 
      oprot.writeFieldEnd()
1408 ankur.sing 11841 
    oprot.writeFieldStop()
11842 
    oprot.writeStructEnd()
11843 
 
3431 rajveer 11844 
  def validate(self):
11845 
    return
11846 
 
11847 
 
1408 ankur.sing 11848 
  def __repr__(self):
11849 
    L = ['%s=%r' % (key, value)
11850 
      for key, value in self.__dict__.iteritems()]
11851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11852 
 
11853 
  def __eq__(self, other):
11854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11855 
 
11856 
  def __ne__(self, other):
11857 
    return not (self == other)
11858 
 
4910 phani.kuma 11859 
class markOrdersAsPickedUp_args:
4410 rajveer 11860 
  """
11861 
  Attributes:
11862 
   - providerId
4910 phani.kuma 11863 
   - pickupDetails
4410 rajveer 11864 
  """
11865 
 
11866 
  thrift_spec = (
11867 
    None, # 0
4910 phani.kuma 11868 
    (1, TType.I64, 'providerId', None, None, ), # 1
11869 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 11870 
  )
11871 
 
4910 phani.kuma 11872 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 11873 
    self.providerId = providerId
4910 phani.kuma 11874 
    self.pickupDetails = pickupDetails
4410 rajveer 11875 
 
11876 
  def read(self, iprot):
11877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11879 
      return
11880 
    iprot.readStructBegin()
11881 
    while True:
11882 
      (fname, ftype, fid) = iprot.readFieldBegin()
11883 
      if ftype == TType.STOP:
11884 
        break
11885 
      if fid == 1:
11886 
        if ftype == TType.I64:
4910 phani.kuma 11887 
          self.providerId = iprot.readI64();
4410 rajveer 11888 
        else:
11889 
          iprot.skip(ftype)
11890 
      elif fid == 2:
4910 phani.kuma 11891 
        if ftype == TType.MAP:
11892 
          self.pickupDetails = {}
5031 varun.gupt 11893 
          (_ktype218, _vtype219, _size217 ) = iprot.readMapBegin()
11894 
          for _i221 in xrange(_size217):
11895 
            _key222 = iprot.readString();
11896 
            _val223 = iprot.readString();
11897 
            self.pickupDetails[_key222] = _val223
4910 phani.kuma 11898 
          iprot.readMapEnd()
4410 rajveer 11899 
        else:
11900 
          iprot.skip(ftype)
11901 
      else:
11902 
        iprot.skip(ftype)
11903 
      iprot.readFieldEnd()
11904 
    iprot.readStructEnd()
11905 
 
11906 
  def write(self, oprot):
11907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11909 
      return
4910 phani.kuma 11910 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 11911 
    if self.providerId is not None:
4910 phani.kuma 11912 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 11913 
      oprot.writeI64(self.providerId)
11914 
      oprot.writeFieldEnd()
4910 phani.kuma 11915 
    if self.pickupDetails is not None:
11916 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11917 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 11918 
      for kiter224,viter225 in self.pickupDetails.items():
11919 
        oprot.writeString(kiter224)
11920 
        oprot.writeString(viter225)
4910 phani.kuma 11921 
      oprot.writeMapEnd()
4410 rajveer 11922 
      oprot.writeFieldEnd()
11923 
    oprot.writeFieldStop()
11924 
    oprot.writeStructEnd()
11925 
 
11926 
  def validate(self):
11927 
    return
11928 
 
11929 
 
11930 
  def __repr__(self):
11931 
    L = ['%s=%r' % (key, value)
11932 
      for key, value in self.__dict__.iteritems()]
11933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11934 
 
11935 
  def __eq__(self, other):
11936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11937 
 
11938 
  def __ne__(self, other):
11939 
    return not (self == other)
11940 
 
4910 phani.kuma 11941 
class markOrdersAsPickedUp_result:
4410 rajveer 11942 
  """
11943 
  Attributes:
11944 
   - ex
11945 
  """
11946 
 
11947 
  thrift_spec = (
4910 phani.kuma 11948 
    None, # 0
4410 rajveer 11949 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11950 
  )
11951 
 
4910 phani.kuma 11952 
  def __init__(self, ex=None,):
4410 rajveer 11953 
    self.ex = ex
11954 
 
11955 
  def read(self, iprot):
11956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11958 
      return
11959 
    iprot.readStructBegin()
11960 
    while True:
11961 
      (fname, ftype, fid) = iprot.readFieldBegin()
11962 
      if ftype == TType.STOP:
11963 
        break
4910 phani.kuma 11964 
      if fid == 1:
4410 rajveer 11965 
        if ftype == TType.STRUCT:
11966 
          self.ex = TransactionServiceException()
11967 
          self.ex.read(iprot)
11968 
        else:
11969 
          iprot.skip(ftype)
11970 
      else:
11971 
        iprot.skip(ftype)
11972 
      iprot.readFieldEnd()
11973 
    iprot.readStructEnd()
11974 
 
11975 
  def write(self, oprot):
11976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11978 
      return
4910 phani.kuma 11979 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 11980 
    if self.ex is not None:
11981 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11982 
      self.ex.write(oprot)
11983 
      oprot.writeFieldEnd()
11984 
    oprot.writeFieldStop()
11985 
    oprot.writeStructEnd()
11986 
 
11987 
  def validate(self):
11988 
    return
11989 
 
11990 
 
11991 
  def __repr__(self):
11992 
    L = ['%s=%r' % (key, value)
11993 
      for key, value in self.__dict__.iteritems()]
11994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11995 
 
11996 
  def __eq__(self, other):
11997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11998 
 
11999 
  def __ne__(self, other):
12000 
    return not (self == other)
12001 
 
4910 phani.kuma 12002 
class getOrdersNotPickedUp_args:
304 ashish 12003 
  """
12004 
  Attributes:
3064 chandransh 12005 
   - providerId
304 ashish 12006 
  """
94 ashish 12007 
 
304 ashish 12008 
  thrift_spec = (
12009 
    None, # 0
3064 chandransh 12010 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 12011 
  )
12012 
 
4910 phani.kuma 12013 
  def __init__(self, providerId=None,):
3064 chandransh 12014 
    self.providerId = providerId
304 ashish 12015 
 
12016 
  def read(self, iprot):
12017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12019 
      return
12020 
    iprot.readStructBegin()
12021 
    while True:
12022 
      (fname, ftype, fid) = iprot.readFieldBegin()
12023 
      if ftype == TType.STOP:
12024 
        break
12025 
      if fid == 1:
12026 
        if ftype == TType.I64:
3064 chandransh 12027 
          self.providerId = iprot.readI64();
304 ashish 12028 
        else:
12029 
          iprot.skip(ftype)
12030 
      else:
12031 
        iprot.skip(ftype)
12032 
      iprot.readFieldEnd()
12033 
    iprot.readStructEnd()
12034 
 
12035 
  def write(self, oprot):
12036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12038 
      return
4910 phani.kuma 12039 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 12040 
    if self.providerId is not None:
3064 chandransh 12041 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12042 
      oprot.writeI64(self.providerId)
304 ashish 12043 
      oprot.writeFieldEnd()
12044 
    oprot.writeFieldStop()
12045 
    oprot.writeStructEnd()
12046 
 
3431 rajveer 12047 
  def validate(self):
12048 
    return
12049 
 
12050 
 
304 ashish 12051 
  def __repr__(self):
12052 
    L = ['%s=%r' % (key, value)
12053 
      for key, value in self.__dict__.iteritems()]
12054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12055 
 
12056 
  def __eq__(self, other):
12057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12058 
 
12059 
  def __ne__(self, other):
12060 
    return not (self == other)
12061 
 
4910 phani.kuma 12062 
class getOrdersNotPickedUp_result:
304 ashish 12063 
  """
12064 
  Attributes:
12065 
   - success
12066 
  """
12067 
 
12068 
  thrift_spec = (
3064 chandransh 12069 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 12070 
  )
12071 
 
4910 phani.kuma 12072 
  def __init__(self, success=None,):
304 ashish 12073 
    self.success = success
12074 
 
12075 
  def read(self, iprot):
12076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12078 
      return
12079 
    iprot.readStructBegin()
12080 
    while True:
12081 
      (fname, ftype, fid) = iprot.readFieldBegin()
12082 
      if ftype == TType.STOP:
12083 
        break
12084 
      if fid == 0:
12085 
        if ftype == TType.LIST:
12086 
          self.success = []
5031 varun.gupt 12087 
          (_etype229, _size226) = iprot.readListBegin()
12088 
          for _i230 in xrange(_size226):
12089 
            _elem231 = Order()
12090 
            _elem231.read(iprot)
12091 
            self.success.append(_elem231)
304 ashish 12092 
          iprot.readListEnd()
12093 
        else:
12094 
          iprot.skip(ftype)
12095 
      else:
12096 
        iprot.skip(ftype)
12097 
      iprot.readFieldEnd()
12098 
    iprot.readStructEnd()
12099 
 
12100 
  def write(self, oprot):
12101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12103 
      return
4910 phani.kuma 12104 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 12105 
    if self.success is not None:
304 ashish 12106 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12107 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12108 
      for iter232 in self.success:
12109 
        iter232.write(oprot)
304 ashish 12110 
      oprot.writeListEnd()
12111 
      oprot.writeFieldEnd()
12112 
    oprot.writeFieldStop()
12113 
    oprot.writeStructEnd()
12114 
 
3431 rajveer 12115 
  def validate(self):
12116 
    return
12117 
 
12118 
 
304 ashish 12119 
  def __repr__(self):
12120 
    L = ['%s=%r' % (key, value)
12121 
      for key, value in self.__dict__.iteritems()]
12122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12123 
 
12124 
  def __eq__(self, other):
12125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12126 
 
12127 
  def __ne__(self, other):
12128 
    return not (self == other)
12129 
 
3064 chandransh 12130 
class markOrdersAsDelivered_args:
304 ashish 12131 
  """
12132 
  Attributes:
3064 chandransh 12133 
   - providerId
12134 
   - deliveredOrders
304 ashish 12135 
  """
12136 
 
12137 
  thrift_spec = (
12138 
    None, # 0
3064 chandransh 12139 
    (1, TType.I64, 'providerId', None, None, ), # 1
12140 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 12141 
  )
12142 
 
3064 chandransh 12143 
  def __init__(self, providerId=None, deliveredOrders=None,):
12144 
    self.providerId = providerId
12145 
    self.deliveredOrders = deliveredOrders
304 ashish 12146 
 
12147 
  def read(self, iprot):
12148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12150 
      return
12151 
    iprot.readStructBegin()
12152 
    while True:
12153 
      (fname, ftype, fid) = iprot.readFieldBegin()
12154 
      if ftype == TType.STOP:
12155 
        break
12156 
      if fid == 1:
12157 
        if ftype == TType.I64:
3064 chandransh 12158 
          self.providerId = iprot.readI64();
304 ashish 12159 
        else:
12160 
          iprot.skip(ftype)
12161 
      elif fid == 2:
3064 chandransh 12162 
        if ftype == TType.MAP:
12163 
          self.deliveredOrders = {}
5031 varun.gupt 12164 
          (_ktype234, _vtype235, _size233 ) = iprot.readMapBegin()
12165 
          for _i237 in xrange(_size233):
12166 
            _key238 = iprot.readString();
12167 
            _val239 = iprot.readString();
12168 
            self.deliveredOrders[_key238] = _val239
3064 chandransh 12169 
          iprot.readMapEnd()
304 ashish 12170 
        else:
12171 
          iprot.skip(ftype)
12172 
      else:
12173 
        iprot.skip(ftype)
12174 
      iprot.readFieldEnd()
12175 
    iprot.readStructEnd()
12176 
 
12177 
  def write(self, oprot):
12178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12180 
      return
3064 chandransh 12181 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 12182 
    if self.providerId is not None:
3064 chandransh 12183 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12184 
      oprot.writeI64(self.providerId)
304 ashish 12185 
      oprot.writeFieldEnd()
3431 rajveer 12186 
    if self.deliveredOrders is not None:
3064 chandransh 12187 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
12188 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
5031 varun.gupt 12189 
      for kiter240,viter241 in self.deliveredOrders.items():
12190 
        oprot.writeString(kiter240)
12191 
        oprot.writeString(viter241)
3064 chandransh 12192 
      oprot.writeMapEnd()
304 ashish 12193 
      oprot.writeFieldEnd()
12194 
    oprot.writeFieldStop()
12195 
    oprot.writeStructEnd()
12196 
 
3431 rajveer 12197 
  def validate(self):
12198 
    return
12199 
 
12200 
 
304 ashish 12201 
  def __repr__(self):
12202 
    L = ['%s=%r' % (key, value)
12203 
      for key, value in self.__dict__.iteritems()]
12204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12205 
 
12206 
  def __eq__(self, other):
12207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12208 
 
12209 
  def __ne__(self, other):
12210 
    return not (self == other)
12211 
 
3064 chandransh 12212 
class markOrdersAsDelivered_result:
12213 
  """
12214 
  Attributes:
12215 
   - ex
12216 
  """
304 ashish 12217 
 
12218 
  thrift_spec = (
3064 chandransh 12219 
    None, # 0
12220 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 12221 
  )
12222 
 
3064 chandransh 12223 
  def __init__(self, ex=None,):
12224 
    self.ex = ex
304 ashish 12225 
 
1596 ankur.sing 12226 
  def read(self, iprot):
12227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12229 
      return
12230 
    iprot.readStructBegin()
12231 
    while True:
12232 
      (fname, ftype, fid) = iprot.readFieldBegin()
12233 
      if ftype == TType.STOP:
12234 
        break
3064 chandransh 12235 
      if fid == 1:
12236 
        if ftype == TType.STRUCT:
12237 
          self.ex = TransactionServiceException()
12238 
          self.ex.read(iprot)
12239 
        else:
12240 
          iprot.skip(ftype)
1596 ankur.sing 12241 
      else:
12242 
        iprot.skip(ftype)
12243 
      iprot.readFieldEnd()
12244 
    iprot.readStructEnd()
12245 
 
12246 
  def write(self, oprot):
12247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12249 
      return
3064 chandransh 12250 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 12251 
    if self.ex is not None:
3064 chandransh 12252 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12253 
      self.ex.write(oprot)
12254 
      oprot.writeFieldEnd()
1596 ankur.sing 12255 
    oprot.writeFieldStop()
12256 
    oprot.writeStructEnd()
12257 
 
3431 rajveer 12258 
  def validate(self):
12259 
    return
12260 
 
12261 
 
1596 ankur.sing 12262 
  def __repr__(self):
12263 
    L = ['%s=%r' % (key, value)
12264 
      for key, value in self.__dict__.iteritems()]
12265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12266 
 
12267 
  def __eq__(self, other):
12268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12269 
 
12270 
  def __ne__(self, other):
12271 
    return not (self == other)
12272 
 
4910 phani.kuma 12273 
class markAsRTOrders_args:
1596 ankur.sing 12274 
  """
12275 
  Attributes:
3064 chandransh 12276 
   - providerId
12277 
   - returnedOrders
1596 ankur.sing 12278 
  """
12279 
 
12280 
  thrift_spec = (
3064 chandransh 12281 
    None, # 0
12282 
    (1, TType.I64, 'providerId', None, None, ), # 1
12283 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 12284 
  )
12285 
 
3064 chandransh 12286 
  def __init__(self, providerId=None, returnedOrders=None,):
12287 
    self.providerId = providerId
12288 
    self.returnedOrders = returnedOrders
1596 ankur.sing 12289 
 
12290 
  def read(self, iprot):
12291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12293 
      return
12294 
    iprot.readStructBegin()
12295 
    while True:
12296 
      (fname, ftype, fid) = iprot.readFieldBegin()
12297 
      if ftype == TType.STOP:
12298 
        break
3064 chandransh 12299 
      if fid == 1:
1596 ankur.sing 12300 
        if ftype == TType.I64:
3064 chandransh 12301 
          self.providerId = iprot.readI64();
1596 ankur.sing 12302 
        else:
12303 
          iprot.skip(ftype)
3064 chandransh 12304 
      elif fid == 2:
12305 
        if ftype == TType.MAP:
12306 
          self.returnedOrders = {}
5031 varun.gupt 12307 
          (_ktype243, _vtype244, _size242 ) = iprot.readMapBegin()
12308 
          for _i246 in xrange(_size242):
12309 
            _key247 = iprot.readString();
12310 
            _val248 = iprot.readString();
12311 
            self.returnedOrders[_key247] = _val248
3064 chandransh 12312 
          iprot.readMapEnd()
12313 
        else:
12314 
          iprot.skip(ftype)
1596 ankur.sing 12315 
      else:
12316 
        iprot.skip(ftype)
12317 
      iprot.readFieldEnd()
12318 
    iprot.readStructEnd()
12319 
 
12320 
  def write(self, oprot):
12321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12323 
      return
4910 phani.kuma 12324 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 12325 
    if self.providerId is not None:
3064 chandransh 12326 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12327 
      oprot.writeI64(self.providerId)
1596 ankur.sing 12328 
      oprot.writeFieldEnd()
3431 rajveer 12329 
    if self.returnedOrders is not None:
3064 chandransh 12330 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
12331 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
5031 varun.gupt 12332 
      for kiter249,viter250 in self.returnedOrders.items():
12333 
        oprot.writeString(kiter249)
12334 
        oprot.writeString(viter250)
3064 chandransh 12335 
      oprot.writeMapEnd()
12336 
      oprot.writeFieldEnd()
1596 ankur.sing 12337 
    oprot.writeFieldStop()
12338 
    oprot.writeStructEnd()
12339 
 
3431 rajveer 12340 
  def validate(self):
12341 
    return
12342 
 
12343 
 
1596 ankur.sing 12344 
  def __repr__(self):
12345 
    L = ['%s=%r' % (key, value)
12346 
      for key, value in self.__dict__.iteritems()]
12347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12348 
 
12349 
  def __eq__(self, other):
12350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12351 
 
12352 
  def __ne__(self, other):
12353 
    return not (self == other)
12354 
 
4910 phani.kuma 12355 
class markAsRTOrders_result:
3064 chandransh 12356 
  """
12357 
  Attributes:
12358 
   - ex
12359 
  """
1596 ankur.sing 12360 
 
1627 ankur.sing 12361 
  thrift_spec = (
3064 chandransh 12362 
    None, # 0
12363 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12364 
  )
12365 
 
3064 chandransh 12366 
  def __init__(self, ex=None,):
12367 
    self.ex = ex
12368 
 
1627 ankur.sing 12369 
  def read(self, iprot):
12370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12372 
      return
12373 
    iprot.readStructBegin()
12374 
    while True:
12375 
      (fname, ftype, fid) = iprot.readFieldBegin()
12376 
      if ftype == TType.STOP:
12377 
        break
3064 chandransh 12378 
      if fid == 1:
12379 
        if ftype == TType.STRUCT:
12380 
          self.ex = TransactionServiceException()
12381 
          self.ex.read(iprot)
12382 
        else:
12383 
          iprot.skip(ftype)
1627 ankur.sing 12384 
      else:
12385 
        iprot.skip(ftype)
12386 
      iprot.readFieldEnd()
12387 
    iprot.readStructEnd()
12388 
 
12389 
  def write(self, oprot):
12390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12392 
      return
4910 phani.kuma 12393 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 12394 
    if self.ex is not None:
3064 chandransh 12395 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12396 
      self.ex.write(oprot)
12397 
      oprot.writeFieldEnd()
1627 ankur.sing 12398 
    oprot.writeFieldStop()
12399 
    oprot.writeStructEnd()
12400 
 
3431 rajveer 12401 
  def validate(self):
12402 
    return
12403 
 
12404 
 
1627 ankur.sing 12405 
  def __repr__(self):
12406 
    L = ['%s=%r' % (key, value)
12407 
      for key, value in self.__dict__.iteritems()]
12408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12409 
 
12410 
  def __eq__(self, other):
12411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12412 
 
12413 
  def __ne__(self, other):
12414 
    return not (self == other)
12415 
 
4910 phani.kuma 12416 
class getRTOrders_args:
12417 
  """
12418 
  Attributes:
12419 
   - providerId
12420 
  """
12421 
 
12422 
  thrift_spec = (
12423 
    None, # 0
12424 
    (1, TType.I64, 'providerId', None, None, ), # 1
12425 
  )
12426 
 
12427 
  def __init__(self, providerId=None,):
12428 
    self.providerId = providerId
12429 
 
12430 
  def read(self, iprot):
12431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12433 
      return
12434 
    iprot.readStructBegin()
12435 
    while True:
12436 
      (fname, ftype, fid) = iprot.readFieldBegin()
12437 
      if ftype == TType.STOP:
12438 
        break
12439 
      if fid == 1:
12440 
        if ftype == TType.I64:
12441 
          self.providerId = iprot.readI64();
12442 
        else:
12443 
          iprot.skip(ftype)
12444 
      else:
12445 
        iprot.skip(ftype)
12446 
      iprot.readFieldEnd()
12447 
    iprot.readStructEnd()
12448 
 
12449 
  def write(self, oprot):
12450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12452 
      return
12453 
    oprot.writeStructBegin('getRTOrders_args')
12454 
    if self.providerId is not None:
12455 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12456 
      oprot.writeI64(self.providerId)
12457 
      oprot.writeFieldEnd()
12458 
    oprot.writeFieldStop()
12459 
    oprot.writeStructEnd()
12460 
 
12461 
  def validate(self):
12462 
    return
12463 
 
12464 
 
12465 
  def __repr__(self):
12466 
    L = ['%s=%r' % (key, value)
12467 
      for key, value in self.__dict__.iteritems()]
12468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12469 
 
12470 
  def __eq__(self, other):
12471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12472 
 
12473 
  def __ne__(self, other):
12474 
    return not (self == other)
12475 
 
12476 
class getRTOrders_result:
12477 
  """
12478 
  Attributes:
12479 
   - success
12480 
  """
12481 
 
12482 
  thrift_spec = (
12483 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12484 
  )
12485 
 
12486 
  def __init__(self, success=None,):
12487 
    self.success = success
12488 
 
12489 
  def read(self, iprot):
12490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12492 
      return
12493 
    iprot.readStructBegin()
12494 
    while True:
12495 
      (fname, ftype, fid) = iprot.readFieldBegin()
12496 
      if ftype == TType.STOP:
12497 
        break
12498 
      if fid == 0:
12499 
        if ftype == TType.LIST:
12500 
          self.success = []
5031 varun.gupt 12501 
          (_etype254, _size251) = iprot.readListBegin()
12502 
          for _i255 in xrange(_size251):
12503 
            _elem256 = Order()
12504 
            _elem256.read(iprot)
12505 
            self.success.append(_elem256)
4910 phani.kuma 12506 
          iprot.readListEnd()
12507 
        else:
12508 
          iprot.skip(ftype)
12509 
      else:
12510 
        iprot.skip(ftype)
12511 
      iprot.readFieldEnd()
12512 
    iprot.readStructEnd()
12513 
 
12514 
  def write(self, oprot):
12515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12517 
      return
12518 
    oprot.writeStructBegin('getRTOrders_result')
12519 
    if self.success is not None:
12520 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12521 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12522 
      for iter257 in self.success:
12523 
        iter257.write(oprot)
4910 phani.kuma 12524 
      oprot.writeListEnd()
12525 
      oprot.writeFieldEnd()
12526 
    oprot.writeFieldStop()
12527 
    oprot.writeStructEnd()
12528 
 
12529 
  def validate(self):
12530 
    return
12531 
 
12532 
 
12533 
  def __repr__(self):
12534 
    L = ['%s=%r' % (key, value)
12535 
      for key, value in self.__dict__.iteritems()]
12536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12537 
 
12538 
  def __eq__(self, other):
12539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12540 
 
12541 
  def __ne__(self, other):
12542 
    return not (self == other)
12543 
 
3064 chandransh 12544 
class updateNonDeliveryReason_args:
1627 ankur.sing 12545 
  """
12546 
  Attributes:
3064 chandransh 12547 
   - providerId
12548 
   - undeliveredOrders
1627 ankur.sing 12549 
  """
12550 
 
12551 
  thrift_spec = (
3064 chandransh 12552 
    None, # 0
12553 
    (1, TType.I64, 'providerId', None, None, ), # 1
12554 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 12555 
  )
12556 
 
3064 chandransh 12557 
  def __init__(self, providerId=None, undeliveredOrders=None,):
12558 
    self.providerId = providerId
12559 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 12560 
 
12561 
  def read(self, iprot):
12562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12564 
      return
12565 
    iprot.readStructBegin()
12566 
    while True:
12567 
      (fname, ftype, fid) = iprot.readFieldBegin()
12568 
      if ftype == TType.STOP:
12569 
        break
3064 chandransh 12570 
      if fid == 1:
1627 ankur.sing 12571 
        if ftype == TType.I64:
3064 chandransh 12572 
          self.providerId = iprot.readI64();
1627 ankur.sing 12573 
        else:
12574 
          iprot.skip(ftype)
3064 chandransh 12575 
      elif fid == 2:
12576 
        if ftype == TType.MAP:
12577 
          self.undeliveredOrders = {}
5031 varun.gupt 12578 
          (_ktype259, _vtype260, _size258 ) = iprot.readMapBegin()
12579 
          for _i262 in xrange(_size258):
12580 
            _key263 = iprot.readString();
12581 
            _val264 = iprot.readString();
12582 
            self.undeliveredOrders[_key263] = _val264
3064 chandransh 12583 
          iprot.readMapEnd()
12584 
        else:
12585 
          iprot.skip(ftype)
1627 ankur.sing 12586 
      else:
12587 
        iprot.skip(ftype)
12588 
      iprot.readFieldEnd()
12589 
    iprot.readStructEnd()
12590 
 
12591 
  def write(self, oprot):
12592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12594 
      return
3064 chandransh 12595 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 12596 
    if self.providerId is not None:
3064 chandransh 12597 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12598 
      oprot.writeI64(self.providerId)
1627 ankur.sing 12599 
      oprot.writeFieldEnd()
3431 rajveer 12600 
    if self.undeliveredOrders is not None:
3064 chandransh 12601 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
12602 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
5031 varun.gupt 12603 
      for kiter265,viter266 in self.undeliveredOrders.items():
12604 
        oprot.writeString(kiter265)
12605 
        oprot.writeString(viter266)
3064 chandransh 12606 
      oprot.writeMapEnd()
12607 
      oprot.writeFieldEnd()
1627 ankur.sing 12608 
    oprot.writeFieldStop()
12609 
    oprot.writeStructEnd()
12610 
 
3431 rajveer 12611 
  def validate(self):
12612 
    return
12613 
 
12614 
 
1627 ankur.sing 12615 
  def __repr__(self):
12616 
    L = ['%s=%r' % (key, value)
12617 
      for key, value in self.__dict__.iteritems()]
12618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12619 
 
12620 
  def __eq__(self, other):
12621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12622 
 
12623 
  def __ne__(self, other):
12624 
    return not (self == other)
12625 
 
3064 chandransh 12626 
class updateNonDeliveryReason_result:
1627 ankur.sing 12627 
  """
12628 
  Attributes:
3064 chandransh 12629 
   - ex
1627 ankur.sing 12630 
  """
12631 
 
12632 
  thrift_spec = (
4910 phani.kuma 12633 
    None, # 0
3064 chandransh 12634 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12635 
  )
12636 
 
4910 phani.kuma 12637 
  def __init__(self, ex=None,):
3064 chandransh 12638 
    self.ex = ex
1627 ankur.sing 12639 
 
12640 
  def read(self, iprot):
12641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12643 
      return
12644 
    iprot.readStructBegin()
12645 
    while True:
12646 
      (fname, ftype, fid) = iprot.readFieldBegin()
12647 
      if ftype == TType.STOP:
12648 
        break
4910 phani.kuma 12649 
      if fid == 1:
12650 
        if ftype == TType.STRUCT:
12651 
          self.ex = TransactionServiceException()
12652 
          self.ex.read(iprot)
12653 
        else:
12654 
          iprot.skip(ftype)
12655 
      else:
12656 
        iprot.skip(ftype)
12657 
      iprot.readFieldEnd()
12658 
    iprot.readStructEnd()
12659 
 
12660 
  def write(self, oprot):
12661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12663 
      return
12664 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
12665 
    if self.ex is not None:
12666 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12667 
      self.ex.write(oprot)
12668 
      oprot.writeFieldEnd()
12669 
    oprot.writeFieldStop()
12670 
    oprot.writeStructEnd()
12671 
 
12672 
  def validate(self):
12673 
    return
12674 
 
12675 
 
12676 
  def __repr__(self):
12677 
    L = ['%s=%r' % (key, value)
12678 
      for key, value in self.__dict__.iteritems()]
12679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12680 
 
12681 
  def __eq__(self, other):
12682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12683 
 
12684 
  def __ne__(self, other):
12685 
    return not (self == other)
12686 
 
12687 
class getNonDeliveredOrdersbyCourier_args:
12688 
  """
12689 
  Attributes:
12690 
   - providerId
12691 
  """
12692 
 
12693 
  thrift_spec = (
12694 
    None, # 0
12695 
    (1, TType.I64, 'providerId', None, None, ), # 1
12696 
  )
12697 
 
12698 
  def __init__(self, providerId=None,):
12699 
    self.providerId = providerId
12700 
 
12701 
  def read(self, iprot):
12702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12704 
      return
12705 
    iprot.readStructBegin()
12706 
    while True:
12707 
      (fname, ftype, fid) = iprot.readFieldBegin()
12708 
      if ftype == TType.STOP:
12709 
        break
12710 
      if fid == 1:
12711 
        if ftype == TType.I64:
12712 
          self.providerId = iprot.readI64();
12713 
        else:
12714 
          iprot.skip(ftype)
12715 
      else:
12716 
        iprot.skip(ftype)
12717 
      iprot.readFieldEnd()
12718 
    iprot.readStructEnd()
12719 
 
12720 
  def write(self, oprot):
12721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12723 
      return
12724 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
12725 
    if self.providerId is not None:
12726 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12727 
      oprot.writeI64(self.providerId)
12728 
      oprot.writeFieldEnd()
12729 
    oprot.writeFieldStop()
12730 
    oprot.writeStructEnd()
12731 
 
12732 
  def validate(self):
12733 
    return
12734 
 
12735 
 
12736 
  def __repr__(self):
12737 
    L = ['%s=%r' % (key, value)
12738 
      for key, value in self.__dict__.iteritems()]
12739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12740 
 
12741 
  def __eq__(self, other):
12742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12743 
 
12744 
  def __ne__(self, other):
12745 
    return not (self == other)
12746 
 
12747 
class getNonDeliveredOrdersbyCourier_result:
12748 
  """
12749 
  Attributes:
12750 
   - success
12751 
  """
12752 
 
12753 
  thrift_spec = (
12754 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12755 
  )
12756 
 
12757 
  def __init__(self, success=None,):
12758 
    self.success = success
12759 
 
12760 
  def read(self, iprot):
12761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12763 
      return
12764 
    iprot.readStructBegin()
12765 
    while True:
12766 
      (fname, ftype, fid) = iprot.readFieldBegin()
12767 
      if ftype == TType.STOP:
12768 
        break
4581 phani.kuma 12769 
      if fid == 0:
12770 
        if ftype == TType.LIST:
12771 
          self.success = []
5031 varun.gupt 12772 
          (_etype270, _size267) = iprot.readListBegin()
12773 
          for _i271 in xrange(_size267):
12774 
            _elem272 = Order()
12775 
            _elem272.read(iprot)
12776 
            self.success.append(_elem272)
4581 phani.kuma 12777 
          iprot.readListEnd()
12778 
        else:
12779 
          iprot.skip(ftype)
4910 phani.kuma 12780 
      else:
12781 
        iprot.skip(ftype)
12782 
      iprot.readFieldEnd()
12783 
    iprot.readStructEnd()
12784 
 
12785 
  def write(self, oprot):
12786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12788 
      return
12789 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
12790 
    if self.success is not None:
12791 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12792 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12793 
      for iter273 in self.success:
12794 
        iter273.write(oprot)
4910 phani.kuma 12795 
      oprot.writeListEnd()
12796 
      oprot.writeFieldEnd()
12797 
    oprot.writeFieldStop()
12798 
    oprot.writeStructEnd()
12799 
 
12800 
  def validate(self):
12801 
    return
12802 
 
12803 
 
12804 
  def __repr__(self):
12805 
    L = ['%s=%r' % (key, value)
12806 
      for key, value in self.__dict__.iteritems()]
12807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12808 
 
12809 
  def __eq__(self, other):
12810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12811 
 
12812 
  def __ne__(self, other):
12813 
    return not (self == other)
12814 
 
12815 
class markOrdersAsLocalConnected_args:
12816 
  """
12817 
  Attributes:
12818 
   - providerId
12819 
   - local_connected_orders
12820 
  """
12821 
 
12822 
  thrift_spec = (
12823 
    None, # 0
12824 
    (1, TType.I64, 'providerId', None, None, ), # 1
12825 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
12826 
  )
12827 
 
12828 
  def __init__(self, providerId=None, local_connected_orders=None,):
12829 
    self.providerId = providerId
12830 
    self.local_connected_orders = local_connected_orders
12831 
 
12832 
  def read(self, iprot):
12833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12835 
      return
12836 
    iprot.readStructBegin()
12837 
    while True:
12838 
      (fname, ftype, fid) = iprot.readFieldBegin()
12839 
      if ftype == TType.STOP:
12840 
        break
12841 
      if fid == 1:
12842 
        if ftype == TType.I64:
12843 
          self.providerId = iprot.readI64();
12844 
        else:
12845 
          iprot.skip(ftype)
12846 
      elif fid == 2:
12847 
        if ftype == TType.MAP:
12848 
          self.local_connected_orders = {}
5031 varun.gupt 12849 
          (_ktype275, _vtype276, _size274 ) = iprot.readMapBegin()
12850 
          for _i278 in xrange(_size274):
12851 
            _key279 = iprot.readString();
12852 
            _val280 = iprot.readString();
12853 
            self.local_connected_orders[_key279] = _val280
4910 phani.kuma 12854 
          iprot.readMapEnd()
12855 
        else:
12856 
          iprot.skip(ftype)
12857 
      else:
12858 
        iprot.skip(ftype)
12859 
      iprot.readFieldEnd()
12860 
    iprot.readStructEnd()
12861 
 
12862 
  def write(self, oprot):
12863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12865 
      return
12866 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
12867 
    if self.providerId is not None:
12868 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12869 
      oprot.writeI64(self.providerId)
12870 
      oprot.writeFieldEnd()
12871 
    if self.local_connected_orders is not None:
12872 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
12873 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
5031 varun.gupt 12874 
      for kiter281,viter282 in self.local_connected_orders.items():
12875 
        oprot.writeString(kiter281)
12876 
        oprot.writeString(viter282)
4910 phani.kuma 12877 
      oprot.writeMapEnd()
12878 
      oprot.writeFieldEnd()
12879 
    oprot.writeFieldStop()
12880 
    oprot.writeStructEnd()
12881 
 
12882 
  def validate(self):
12883 
    return
12884 
 
12885 
 
12886 
  def __repr__(self):
12887 
    L = ['%s=%r' % (key, value)
12888 
      for key, value in self.__dict__.iteritems()]
12889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12890 
 
12891 
  def __eq__(self, other):
12892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12893 
 
12894 
  def __ne__(self, other):
12895 
    return not (self == other)
12896 
 
12897 
class markOrdersAsLocalConnected_result:
12898 
  """
12899 
  Attributes:
12900 
   - ex
12901 
  """
12902 
 
12903 
  thrift_spec = (
12904 
    None, # 0
12905 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12906 
  )
12907 
 
12908 
  def __init__(self, ex=None,):
12909 
    self.ex = ex
12910 
 
12911 
  def read(self, iprot):
12912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12914 
      return
12915 
    iprot.readStructBegin()
12916 
    while True:
12917 
      (fname, ftype, fid) = iprot.readFieldBegin()
12918 
      if ftype == TType.STOP:
12919 
        break
12920 
      if fid == 1:
3064 chandransh 12921 
        if ftype == TType.STRUCT:
12922 
          self.ex = TransactionServiceException()
12923 
          self.ex.read(iprot)
1627 ankur.sing 12924 
        else:
12925 
          iprot.skip(ftype)
12926 
      else:
12927 
        iprot.skip(ftype)
12928 
      iprot.readFieldEnd()
12929 
    iprot.readStructEnd()
12930 
 
12931 
  def write(self, oprot):
12932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12934 
      return
4910 phani.kuma 12935 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
12936 
    if self.ex is not None:
12937 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12938 
      self.ex.write(oprot)
12939 
      oprot.writeFieldEnd()
12940 
    oprot.writeFieldStop()
12941 
    oprot.writeStructEnd()
12942 
 
12943 
  def validate(self):
12944 
    return
12945 
 
12946 
 
12947 
  def __repr__(self):
12948 
    L = ['%s=%r' % (key, value)
12949 
      for key, value in self.__dict__.iteritems()]
12950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12951 
 
12952 
  def __eq__(self, other):
12953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12954 
 
12955 
  def __ne__(self, other):
12956 
    return not (self == other)
12957 
 
12958 
class getOrdersNotLocalConnected_args:
12959 
  """
12960 
  Attributes:
12961 
   - providerId
12962 
  """
12963 
 
12964 
  thrift_spec = (
12965 
    None, # 0
12966 
    (1, TType.I64, 'providerId', None, None, ), # 1
12967 
  )
12968 
 
12969 
  def __init__(self, providerId=None,):
12970 
    self.providerId = providerId
12971 
 
12972 
  def read(self, iprot):
12973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12975 
      return
12976 
    iprot.readStructBegin()
12977 
    while True:
12978 
      (fname, ftype, fid) = iprot.readFieldBegin()
12979 
      if ftype == TType.STOP:
12980 
        break
12981 
      if fid == 1:
12982 
        if ftype == TType.I64:
12983 
          self.providerId = iprot.readI64();
12984 
        else:
12985 
          iprot.skip(ftype)
12986 
      else:
12987 
        iprot.skip(ftype)
12988 
      iprot.readFieldEnd()
12989 
    iprot.readStructEnd()
12990 
 
12991 
  def write(self, oprot):
12992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12994 
      return
12995 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
12996 
    if self.providerId is not None:
12997 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12998 
      oprot.writeI64(self.providerId)
12999 
      oprot.writeFieldEnd()
13000 
    oprot.writeFieldStop()
13001 
    oprot.writeStructEnd()
13002 
 
13003 
  def validate(self):
13004 
    return
13005 
 
13006 
 
13007 
  def __repr__(self):
13008 
    L = ['%s=%r' % (key, value)
13009 
      for key, value in self.__dict__.iteritems()]
13010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13011 
 
13012 
  def __eq__(self, other):
13013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13014 
 
13015 
  def __ne__(self, other):
13016 
    return not (self == other)
13017 
 
13018 
class getOrdersNotLocalConnected_result:
13019 
  """
13020 
  Attributes:
13021 
   - success
13022 
  """
13023 
 
13024 
  thrift_spec = (
13025 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13026 
  )
13027 
 
13028 
  def __init__(self, success=None,):
13029 
    self.success = success
13030 
 
13031 
  def read(self, iprot):
13032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13034 
      return
13035 
    iprot.readStructBegin()
13036 
    while True:
13037 
      (fname, ftype, fid) = iprot.readFieldBegin()
13038 
      if ftype == TType.STOP:
13039 
        break
13040 
      if fid == 0:
13041 
        if ftype == TType.LIST:
13042 
          self.success = []
5031 varun.gupt 13043 
          (_etype286, _size283) = iprot.readListBegin()
13044 
          for _i287 in xrange(_size283):
13045 
            _elem288 = Order()
13046 
            _elem288.read(iprot)
13047 
            self.success.append(_elem288)
4910 phani.kuma 13048 
          iprot.readListEnd()
13049 
        else:
13050 
          iprot.skip(ftype)
13051 
      else:
13052 
        iprot.skip(ftype)
13053 
      iprot.readFieldEnd()
13054 
    iprot.readStructEnd()
13055 
 
13056 
  def write(self, oprot):
13057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13059 
      return
13060 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 13061 
    if self.success is not None:
13062 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13063 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13064 
      for iter289 in self.success:
13065 
        iter289.write(oprot)
4581 phani.kuma 13066 
      oprot.writeListEnd()
13067 
      oprot.writeFieldEnd()
4910 phani.kuma 13068 
    oprot.writeFieldStop()
13069 
    oprot.writeStructEnd()
13070 
 
13071 
  def validate(self):
13072 
    return
13073 
 
13074 
 
13075 
  def __repr__(self):
13076 
    L = ['%s=%r' % (key, value)
13077 
      for key, value in self.__dict__.iteritems()]
13078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13079 
 
13080 
  def __eq__(self, other):
13081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13082 
 
13083 
  def __ne__(self, other):
13084 
    return not (self == other)
13085 
 
13086 
class markOrdersAsDestinationCityReached_args:
13087 
  """
13088 
  Attributes:
13089 
   - providerId
13090 
   - destination_city_reached_orders
13091 
  """
13092 
 
13093 
  thrift_spec = (
13094 
    None, # 0
13095 
    (1, TType.I64, 'providerId', None, None, ), # 1
13096 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13097 
  )
13098 
 
13099 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
13100 
    self.providerId = providerId
13101 
    self.destination_city_reached_orders = destination_city_reached_orders
13102 
 
13103 
  def read(self, iprot):
13104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13106 
      return
13107 
    iprot.readStructBegin()
13108 
    while True:
13109 
      (fname, ftype, fid) = iprot.readFieldBegin()
13110 
      if ftype == TType.STOP:
13111 
        break
13112 
      if fid == 1:
13113 
        if ftype == TType.I64:
13114 
          self.providerId = iprot.readI64();
13115 
        else:
13116 
          iprot.skip(ftype)
13117 
      elif fid == 2:
13118 
        if ftype == TType.MAP:
13119 
          self.destination_city_reached_orders = {}
5031 varun.gupt 13120 
          (_ktype291, _vtype292, _size290 ) = iprot.readMapBegin()
13121 
          for _i294 in xrange(_size290):
13122 
            _key295 = iprot.readString();
13123 
            _val296 = iprot.readString();
13124 
            self.destination_city_reached_orders[_key295] = _val296
4910 phani.kuma 13125 
          iprot.readMapEnd()
13126 
        else:
13127 
          iprot.skip(ftype)
13128 
      else:
13129 
        iprot.skip(ftype)
13130 
      iprot.readFieldEnd()
13131 
    iprot.readStructEnd()
13132 
 
13133 
  def write(self, oprot):
13134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13136 
      return
13137 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
13138 
    if self.providerId is not None:
13139 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13140 
      oprot.writeI64(self.providerId)
13141 
      oprot.writeFieldEnd()
13142 
    if self.destination_city_reached_orders is not None:
13143 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
13144 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
5031 varun.gupt 13145 
      for kiter297,viter298 in self.destination_city_reached_orders.items():
13146 
        oprot.writeString(kiter297)
13147 
        oprot.writeString(viter298)
4910 phani.kuma 13148 
      oprot.writeMapEnd()
13149 
      oprot.writeFieldEnd()
13150 
    oprot.writeFieldStop()
13151 
    oprot.writeStructEnd()
13152 
 
13153 
  def validate(self):
13154 
    return
13155 
 
13156 
 
13157 
  def __repr__(self):
13158 
    L = ['%s=%r' % (key, value)
13159 
      for key, value in self.__dict__.iteritems()]
13160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13161 
 
13162 
  def __eq__(self, other):
13163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13164 
 
13165 
  def __ne__(self, other):
13166 
    return not (self == other)
13167 
 
13168 
class markOrdersAsDestinationCityReached_result:
13169 
  """
13170 
  Attributes:
13171 
   - ex
13172 
  """
13173 
 
13174 
  thrift_spec = (
13175 
    None, # 0
13176 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13177 
  )
13178 
 
13179 
  def __init__(self, ex=None,):
13180 
    self.ex = ex
13181 
 
13182 
  def read(self, iprot):
13183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13185 
      return
13186 
    iprot.readStructBegin()
13187 
    while True:
13188 
      (fname, ftype, fid) = iprot.readFieldBegin()
13189 
      if ftype == TType.STOP:
13190 
        break
13191 
      if fid == 1:
13192 
        if ftype == TType.STRUCT:
13193 
          self.ex = TransactionServiceException()
13194 
          self.ex.read(iprot)
13195 
        else:
13196 
          iprot.skip(ftype)
13197 
      else:
13198 
        iprot.skip(ftype)
13199 
      iprot.readFieldEnd()
13200 
    iprot.readStructEnd()
13201 
 
13202 
  def write(self, oprot):
13203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13205 
      return
13206 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 13207 
    if self.ex is not None:
3064 chandransh 13208 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13209 
      self.ex.write(oprot)
1627 ankur.sing 13210 
      oprot.writeFieldEnd()
13211 
    oprot.writeFieldStop()
13212 
    oprot.writeStructEnd()
13213 
 
3431 rajveer 13214 
  def validate(self):
13215 
    return
13216 
 
13217 
 
1627 ankur.sing 13218 
  def __repr__(self):
13219 
    L = ['%s=%r' % (key, value)
13220 
      for key, value in self.__dict__.iteritems()]
13221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13222 
 
13223 
  def __eq__(self, other):
13224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13225 
 
13226 
  def __ne__(self, other):
13227 
    return not (self == other)
13228 
 
4910 phani.kuma 13229 
class markOrdersAsFirstDeliveryAttempted_args:
13230 
  """
13231 
  Attributes:
13232 
   - providerId
13233 
   - first_atdl_orders
13234 
  """
13235 
 
13236 
  thrift_spec = (
13237 
    None, # 0
13238 
    (1, TType.I64, 'providerId', None, None, ), # 1
13239 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13240 
  )
13241 
 
13242 
  def __init__(self, providerId=None, first_atdl_orders=None,):
13243 
    self.providerId = providerId
13244 
    self.first_atdl_orders = first_atdl_orders
13245 
 
13246 
  def read(self, iprot):
13247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13249 
      return
13250 
    iprot.readStructBegin()
13251 
    while True:
13252 
      (fname, ftype, fid) = iprot.readFieldBegin()
13253 
      if ftype == TType.STOP:
13254 
        break
13255 
      if fid == 1:
13256 
        if ftype == TType.I64:
13257 
          self.providerId = iprot.readI64();
13258 
        else:
13259 
          iprot.skip(ftype)
13260 
      elif fid == 2:
13261 
        if ftype == TType.MAP:
13262 
          self.first_atdl_orders = {}
5031 varun.gupt 13263 
          (_ktype300, _vtype301, _size299 ) = iprot.readMapBegin()
13264 
          for _i303 in xrange(_size299):
13265 
            _key304 = iprot.readString();
13266 
            _val305 = iprot.readString();
13267 
            self.first_atdl_orders[_key304] = _val305
4910 phani.kuma 13268 
          iprot.readMapEnd()
13269 
        else:
13270 
          iprot.skip(ftype)
13271 
      else:
13272 
        iprot.skip(ftype)
13273 
      iprot.readFieldEnd()
13274 
    iprot.readStructEnd()
13275 
 
13276 
  def write(self, oprot):
13277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13279 
      return
13280 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
13281 
    if self.providerId is not None:
13282 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13283 
      oprot.writeI64(self.providerId)
13284 
      oprot.writeFieldEnd()
13285 
    if self.first_atdl_orders is not None:
13286 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
13287 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
5031 varun.gupt 13288 
      for kiter306,viter307 in self.first_atdl_orders.items():
13289 
        oprot.writeString(kiter306)
13290 
        oprot.writeString(viter307)
4910 phani.kuma 13291 
      oprot.writeMapEnd()
13292 
      oprot.writeFieldEnd()
13293 
    oprot.writeFieldStop()
13294 
    oprot.writeStructEnd()
13295 
 
13296 
  def validate(self):
13297 
    return
13298 
 
13299 
 
13300 
  def __repr__(self):
13301 
    L = ['%s=%r' % (key, value)
13302 
      for key, value in self.__dict__.iteritems()]
13303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13304 
 
13305 
  def __eq__(self, other):
13306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13307 
 
13308 
  def __ne__(self, other):
13309 
    return not (self == other)
13310 
 
13311 
class markOrdersAsFirstDeliveryAttempted_result:
13312 
  """
13313 
  Attributes:
13314 
   - ex
13315 
  """
13316 
 
13317 
  thrift_spec = (
13318 
    None, # 0
13319 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13320 
  )
13321 
 
13322 
  def __init__(self, ex=None,):
13323 
    self.ex = ex
13324 
 
13325 
  def read(self, iprot):
13326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13328 
      return
13329 
    iprot.readStructBegin()
13330 
    while True:
13331 
      (fname, ftype, fid) = iprot.readFieldBegin()
13332 
      if ftype == TType.STOP:
13333 
        break
13334 
      if fid == 1:
13335 
        if ftype == TType.STRUCT:
13336 
          self.ex = TransactionServiceException()
13337 
          self.ex.read(iprot)
13338 
        else:
13339 
          iprot.skip(ftype)
13340 
      else:
13341 
        iprot.skip(ftype)
13342 
      iprot.readFieldEnd()
13343 
    iprot.readStructEnd()
13344 
 
13345 
  def write(self, oprot):
13346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13348 
      return
13349 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
13350 
    if self.ex is not None:
13351 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13352 
      self.ex.write(oprot)
13353 
      oprot.writeFieldEnd()
13354 
    oprot.writeFieldStop()
13355 
    oprot.writeStructEnd()
13356 
 
13357 
  def validate(self):
13358 
    return
13359 
 
13360 
 
13361 
  def __repr__(self):
13362 
    L = ['%s=%r' % (key, value)
13363 
      for key, value in self.__dict__.iteritems()]
13364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13365 
 
13366 
  def __eq__(self, other):
13367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13368 
 
13369 
  def __ne__(self, other):
13370 
    return not (self == other)
13371 
 
3064 chandransh 13372 
class getUndeliveredOrders_args:
1886 ankur.sing 13373 
  """
13374 
  Attributes:
3064 chandransh 13375 
   - providerId
13376 
   - warehouseId
1886 ankur.sing 13377 
  """
1627 ankur.sing 13378 
 
1886 ankur.sing 13379 
  thrift_spec = (
13380 
    None, # 0
3064 chandransh 13381 
    (1, TType.I64, 'providerId', None, None, ), # 1
13382 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 13383 
  )
13384 
 
3064 chandransh 13385 
  def __init__(self, providerId=None, warehouseId=None,):
13386 
    self.providerId = providerId
13387 
    self.warehouseId = warehouseId
1886 ankur.sing 13388 
 
13389 
  def read(self, iprot):
13390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13392 
      return
13393 
    iprot.readStructBegin()
13394 
    while True:
13395 
      (fname, ftype, fid) = iprot.readFieldBegin()
13396 
      if ftype == TType.STOP:
13397 
        break
13398 
      if fid == 1:
13399 
        if ftype == TType.I64:
3064 chandransh 13400 
          self.providerId = iprot.readI64();
1886 ankur.sing 13401 
        else:
13402 
          iprot.skip(ftype)
3064 chandransh 13403 
      elif fid == 2:
13404 
        if ftype == TType.I64:
13405 
          self.warehouseId = iprot.readI64();
13406 
        else:
13407 
          iprot.skip(ftype)
1886 ankur.sing 13408 
      else:
13409 
        iprot.skip(ftype)
13410 
      iprot.readFieldEnd()
13411 
    iprot.readStructEnd()
13412 
 
13413 
  def write(self, oprot):
13414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13416 
      return
3064 chandransh 13417 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 13418 
    if self.providerId is not None:
3064 chandransh 13419 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13420 
      oprot.writeI64(self.providerId)
1886 ankur.sing 13421 
      oprot.writeFieldEnd()
3431 rajveer 13422 
    if self.warehouseId is not None:
3064 chandransh 13423 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13424 
      oprot.writeI64(self.warehouseId)
13425 
      oprot.writeFieldEnd()
1886 ankur.sing 13426 
    oprot.writeFieldStop()
13427 
    oprot.writeStructEnd()
13428 
 
3431 rajveer 13429 
  def validate(self):
13430 
    return
13431 
 
13432 
 
1886 ankur.sing 13433 
  def __repr__(self):
13434 
    L = ['%s=%r' % (key, value)
13435 
      for key, value in self.__dict__.iteritems()]
13436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13437 
 
13438 
  def __eq__(self, other):
13439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13440 
 
13441 
  def __ne__(self, other):
13442 
    return not (self == other)
13443 
 
3064 chandransh 13444 
class getUndeliveredOrders_result:
1886 ankur.sing 13445 
  """
13446 
  Attributes:
13447 
   - success
13448 
  """
13449 
 
13450 
  thrift_spec = (
13451 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13452 
  )
13453 
 
13454 
  def __init__(self, success=None,):
13455 
    self.success = success
13456 
 
13457 
  def read(self, iprot):
13458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13460 
      return
13461 
    iprot.readStructBegin()
13462 
    while True:
13463 
      (fname, ftype, fid) = iprot.readFieldBegin()
13464 
      if ftype == TType.STOP:
13465 
        break
13466 
      if fid == 0:
13467 
        if ftype == TType.LIST:
13468 
          self.success = []
5031 varun.gupt 13469 
          (_etype311, _size308) = iprot.readListBegin()
13470 
          for _i312 in xrange(_size308):
13471 
            _elem313 = Order()
13472 
            _elem313.read(iprot)
13473 
            self.success.append(_elem313)
1886 ankur.sing 13474 
          iprot.readListEnd()
13475 
        else:
13476 
          iprot.skip(ftype)
13477 
      else:
13478 
        iprot.skip(ftype)
13479 
      iprot.readFieldEnd()
13480 
    iprot.readStructEnd()
13481 
 
13482 
  def write(self, oprot):
13483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13485 
      return
3064 chandransh 13486 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 13487 
    if self.success is not None:
1886 ankur.sing 13488 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13489 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13490 
      for iter314 in self.success:
13491 
        iter314.write(oprot)
1886 ankur.sing 13492 
      oprot.writeListEnd()
13493 
      oprot.writeFieldEnd()
13494 
    oprot.writeFieldStop()
13495 
    oprot.writeStructEnd()
13496 
 
3431 rajveer 13497 
  def validate(self):
13498 
    return
13499 
 
13500 
 
1886 ankur.sing 13501 
  def __repr__(self):
13502 
    L = ['%s=%r' % (key, value)
13503 
      for key, value in self.__dict__.iteritems()]
13504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13505 
 
13506 
  def __eq__(self, other):
13507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13508 
 
13509 
  def __ne__(self, other):
13510 
    return not (self == other)
13511 
 
4783 phani.kuma 13512 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
13513 
 
13514 
  thrift_spec = (
13515 
  )
13516 
 
13517 
  def read(self, iprot):
13518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13520 
      return
13521 
    iprot.readStructBegin()
13522 
    while True:
13523 
      (fname, ftype, fid) = iprot.readFieldBegin()
13524 
      if ftype == TType.STOP:
13525 
        break
13526 
      else:
13527 
        iprot.skip(ftype)
13528 
      iprot.readFieldEnd()
13529 
    iprot.readStructEnd()
13530 
 
13531 
  def write(self, oprot):
13532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13534 
      return
13535 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
13536 
    oprot.writeFieldStop()
13537 
    oprot.writeStructEnd()
13538 
 
13539 
  def validate(self):
13540 
    return
13541 
 
13542 
 
13543 
  def __repr__(self):
13544 
    L = ['%s=%r' % (key, value)
13545 
      for key, value in self.__dict__.iteritems()]
13546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13547 
 
13548 
  def __eq__(self, other):
13549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13550 
 
13551 
  def __ne__(self, other):
13552 
    return not (self == other)
13553 
 
13554 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
13555 
  """
13556 
  Attributes:
13557 
   - success
13558 
  """
13559 
 
13560 
  thrift_spec = (
13561 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13562 
  )
13563 
 
13564 
  def __init__(self, success=None,):
13565 
    self.success = success
13566 
 
13567 
  def read(self, iprot):
13568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13570 
      return
13571 
    iprot.readStructBegin()
13572 
    while True:
13573 
      (fname, ftype, fid) = iprot.readFieldBegin()
13574 
      if ftype == TType.STOP:
13575 
        break
13576 
      if fid == 0:
13577 
        if ftype == TType.LIST:
13578 
          self.success = []
5031 varun.gupt 13579 
          (_etype318, _size315) = iprot.readListBegin()
13580 
          for _i319 in xrange(_size315):
13581 
            _elem320 = Order()
13582 
            _elem320.read(iprot)
13583 
            self.success.append(_elem320)
4783 phani.kuma 13584 
          iprot.readListEnd()
13585 
        else:
13586 
          iprot.skip(ftype)
13587 
      else:
13588 
        iprot.skip(ftype)
13589 
      iprot.readFieldEnd()
13590 
    iprot.readStructEnd()
13591 
 
13592 
  def write(self, oprot):
13593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13595 
      return
13596 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
13597 
    if self.success is not None:
13598 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13599 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13600 
      for iter321 in self.success:
13601 
        iter321.write(oprot)
4783 phani.kuma 13602 
      oprot.writeListEnd()
13603 
      oprot.writeFieldEnd()
13604 
    oprot.writeFieldStop()
13605 
    oprot.writeStructEnd()
13606 
 
13607 
  def validate(self):
13608 
    return
13609 
 
13610 
 
13611 
  def __repr__(self):
13612 
    L = ['%s=%r' % (key, value)
13613 
      for key, value in self.__dict__.iteritems()]
13614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13615 
 
13616 
  def __eq__(self, other):
13617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13618 
 
13619 
  def __ne__(self, other):
13620 
    return not (self == other)
13621 
 
2536 chandransh 13622 
class toggleDOAFlag_args:
13623 
  """
13624 
  Attributes:
13625 
   - orderId
13626 
  """
1886 ankur.sing 13627 
 
2536 chandransh 13628 
  thrift_spec = (
13629 
    None, # 0
13630 
    (1, TType.I64, 'orderId', None, None, ), # 1
13631 
  )
13632 
 
13633 
  def __init__(self, orderId=None,):
13634 
    self.orderId = orderId
13635 
 
13636 
  def read(self, iprot):
13637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13639 
      return
13640 
    iprot.readStructBegin()
13641 
    while True:
13642 
      (fname, ftype, fid) = iprot.readFieldBegin()
13643 
      if ftype == TType.STOP:
13644 
        break
13645 
      if fid == 1:
13646 
        if ftype == TType.I64:
13647 
          self.orderId = iprot.readI64();
13648 
        else:
13649 
          iprot.skip(ftype)
13650 
      else:
13651 
        iprot.skip(ftype)
13652 
      iprot.readFieldEnd()
13653 
    iprot.readStructEnd()
13654 
 
13655 
  def write(self, oprot):
13656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13658 
      return
13659 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 13660 
    if self.orderId is not None:
2536 chandransh 13661 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13662 
      oprot.writeI64(self.orderId)
13663 
      oprot.writeFieldEnd()
13664 
    oprot.writeFieldStop()
13665 
    oprot.writeStructEnd()
13666 
 
3431 rajveer 13667 
  def validate(self):
13668 
    return
13669 
 
13670 
 
2536 chandransh 13671 
  def __repr__(self):
13672 
    L = ['%s=%r' % (key, value)
13673 
      for key, value in self.__dict__.iteritems()]
13674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13675 
 
13676 
  def __eq__(self, other):
13677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13678 
 
13679 
  def __ne__(self, other):
13680 
    return not (self == other)
13681 
 
13682 
class toggleDOAFlag_result:
13683 
  """
13684 
  Attributes:
13685 
   - success
13686 
   - ex
13687 
  """
13688 
 
13689 
  thrift_spec = (
13690 
    (0, TType.BOOL, 'success', None, None, ), # 0
13691 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13692 
  )
13693 
 
13694 
  def __init__(self, success=None, ex=None,):
13695 
    self.success = success
13696 
    self.ex = ex
13697 
 
13698 
  def read(self, iprot):
13699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13701 
      return
13702 
    iprot.readStructBegin()
13703 
    while True:
13704 
      (fname, ftype, fid) = iprot.readFieldBegin()
13705 
      if ftype == TType.STOP:
13706 
        break
13707 
      if fid == 0:
13708 
        if ftype == TType.BOOL:
13709 
          self.success = iprot.readBool();
13710 
        else:
13711 
          iprot.skip(ftype)
13712 
      elif fid == 1:
13713 
        if ftype == TType.STRUCT:
13714 
          self.ex = TransactionServiceException()
13715 
          self.ex.read(iprot)
13716 
        else:
13717 
          iprot.skip(ftype)
13718 
      else:
13719 
        iprot.skip(ftype)
13720 
      iprot.readFieldEnd()
13721 
    iprot.readStructEnd()
13722 
 
13723 
  def write(self, oprot):
13724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13726 
      return
13727 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 13728 
    if self.success is not None:
2536 chandransh 13729 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13730 
      oprot.writeBool(self.success)
13731 
      oprot.writeFieldEnd()
3431 rajveer 13732 
    if self.ex is not None:
2536 chandransh 13733 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13734 
      self.ex.write(oprot)
13735 
      oprot.writeFieldEnd()
13736 
    oprot.writeFieldStop()
13737 
    oprot.writeStructEnd()
13738 
 
3431 rajveer 13739 
  def validate(self):
13740 
    return
13741 
 
13742 
 
2536 chandransh 13743 
  def __repr__(self):
13744 
    L = ['%s=%r' % (key, value)
13745 
      for key, value in self.__dict__.iteritems()]
13746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13747 
 
13748 
  def __eq__(self, other):
13749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13750 
 
13751 
  def __ne__(self, other):
13752 
    return not (self == other)
13753 
 
4712 rajveer 13754 
class markOrderAsDelivered_args:
13755 
  """
13756 
  Attributes:
13757 
   - orderId
13758 
   - deliveryTimestamp
13759 
   - receiver
13760 
  """
13761 
 
13762 
  thrift_spec = None
13763 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
13764 
    self.orderId = orderId
13765 
    self.deliveryTimestamp = deliveryTimestamp
13766 
    self.receiver = receiver
13767 
 
13768 
  def read(self, iprot):
13769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13771 
      return
13772 
    iprot.readStructBegin()
13773 
    while True:
13774 
      (fname, ftype, fid) = iprot.readFieldBegin()
13775 
      if ftype == TType.STOP:
13776 
        break
13777 
      if fid == 1:
13778 
        if ftype == TType.I64:
13779 
          self.orderId = iprot.readI64();
13780 
        else:
13781 
          iprot.skip(ftype)
13782 
      elif fid == 2:
13783 
        if ftype == TType.I64:
13784 
          self.deliveryTimestamp = iprot.readI64();
13785 
        else:
13786 
          iprot.skip(ftype)
13787 
      elif fid == -1:
13788 
        if ftype == TType.STRING:
13789 
          self.receiver = iprot.readString();
13790 
        else:
13791 
          iprot.skip(ftype)
13792 
      else:
13793 
        iprot.skip(ftype)
13794 
      iprot.readFieldEnd()
13795 
    iprot.readStructEnd()
13796 
 
13797 
  def write(self, oprot):
13798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13800 
      return
13801 
    oprot.writeStructBegin('markOrderAsDelivered_args')
13802 
    if self.receiver is not None:
13803 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
13804 
      oprot.writeString(self.receiver)
13805 
      oprot.writeFieldEnd()
13806 
    if self.orderId is not None:
13807 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13808 
      oprot.writeI64(self.orderId)
13809 
      oprot.writeFieldEnd()
13810 
    if self.deliveryTimestamp is not None:
13811 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
13812 
      oprot.writeI64(self.deliveryTimestamp)
13813 
      oprot.writeFieldEnd()
13814 
    oprot.writeFieldStop()
13815 
    oprot.writeStructEnd()
13816 
 
13817 
  def validate(self):
13818 
    return
13819 
 
13820 
 
13821 
  def __repr__(self):
13822 
    L = ['%s=%r' % (key, value)
13823 
      for key, value in self.__dict__.iteritems()]
13824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13825 
 
13826 
  def __eq__(self, other):
13827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13828 
 
13829 
  def __ne__(self, other):
13830 
    return not (self == other)
13831 
 
13832 
class markOrderAsDelivered_result:
13833 
  """
13834 
  Attributes:
13835 
   - ex
13836 
  """
13837 
 
13838 
  thrift_spec = (
13839 
    None, # 0
13840 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13841 
  )
13842 
 
13843 
  def __init__(self, ex=None,):
13844 
    self.ex = ex
13845 
 
13846 
  def read(self, iprot):
13847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13849 
      return
13850 
    iprot.readStructBegin()
13851 
    while True:
13852 
      (fname, ftype, fid) = iprot.readFieldBegin()
13853 
      if ftype == TType.STOP:
13854 
        break
13855 
      if fid == 1:
13856 
        if ftype == TType.STRUCT:
13857 
          self.ex = TransactionServiceException()
13858 
          self.ex.read(iprot)
13859 
        else:
13860 
          iprot.skip(ftype)
13861 
      else:
13862 
        iprot.skip(ftype)
13863 
      iprot.readFieldEnd()
13864 
    iprot.readStructEnd()
13865 
 
13866 
  def write(self, oprot):
13867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13869 
      return
13870 
    oprot.writeStructBegin('markOrderAsDelivered_result')
13871 
    if self.ex is not None:
13872 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13873 
      self.ex.write(oprot)
13874 
      oprot.writeFieldEnd()
13875 
    oprot.writeFieldStop()
13876 
    oprot.writeStructEnd()
13877 
 
13878 
  def validate(self):
13879 
    return
13880 
 
13881 
 
13882 
  def __repr__(self):
13883 
    L = ['%s=%r' % (key, value)
13884 
      for key, value in self.__dict__.iteritems()]
13885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13886 
 
13887 
  def __eq__(self, other):
13888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13889 
 
13890 
  def __ne__(self, other):
13891 
    return not (self == other)
13892 
 
4454 rajveer 13893 
class markOrderDoaRequestReceived_args:
13894 
  """
13895 
  Attributes:
13896 
   - orderId
13897 
  """
13898 
 
13899 
  thrift_spec = (
13900 
    None, # 0
13901 
    (1, TType.I64, 'orderId', None, None, ), # 1
13902 
  )
13903 
 
13904 
  def __init__(self, orderId=None,):
13905 
    self.orderId = orderId
13906 
 
13907 
  def read(self, iprot):
13908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13910 
      return
13911 
    iprot.readStructBegin()
13912 
    while True:
13913 
      (fname, ftype, fid) = iprot.readFieldBegin()
13914 
      if ftype == TType.STOP:
13915 
        break
13916 
      if fid == 1:
13917 
        if ftype == TType.I64:
13918 
          self.orderId = iprot.readI64();
13919 
        else:
13920 
          iprot.skip(ftype)
13921 
      else:
13922 
        iprot.skip(ftype)
13923 
      iprot.readFieldEnd()
13924 
    iprot.readStructEnd()
13925 
 
13926 
  def write(self, oprot):
13927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13929 
      return
13930 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
13931 
    if self.orderId is not None:
13932 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13933 
      oprot.writeI64(self.orderId)
13934 
      oprot.writeFieldEnd()
13935 
    oprot.writeFieldStop()
13936 
    oprot.writeStructEnd()
13937 
 
13938 
  def validate(self):
13939 
    return
13940 
 
13941 
 
13942 
  def __repr__(self):
13943 
    L = ['%s=%r' % (key, value)
13944 
      for key, value in self.__dict__.iteritems()]
13945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13946 
 
13947 
  def __eq__(self, other):
13948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13949 
 
13950 
  def __ne__(self, other):
13951 
    return not (self == other)
13952 
 
13953 
class markOrderDoaRequestReceived_result:
13954 
  """
13955 
  Attributes:
13956 
   - success
13957 
   - ex
13958 
  """
13959 
 
13960 
  thrift_spec = (
13961 
    (0, TType.BOOL, 'success', None, None, ), # 0
13962 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13963 
  )
13964 
 
13965 
  def __init__(self, success=None, ex=None,):
13966 
    self.success = success
13967 
    self.ex = ex
13968 
 
13969 
  def read(self, iprot):
13970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13972 
      return
13973 
    iprot.readStructBegin()
13974 
    while True:
13975 
      (fname, ftype, fid) = iprot.readFieldBegin()
13976 
      if ftype == TType.STOP:
13977 
        break
13978 
      if fid == 0:
13979 
        if ftype == TType.BOOL:
13980 
          self.success = iprot.readBool();
13981 
        else:
13982 
          iprot.skip(ftype)
13983 
      elif fid == 1:
13984 
        if ftype == TType.STRUCT:
13985 
          self.ex = TransactionServiceException()
13986 
          self.ex.read(iprot)
13987 
        else:
13988 
          iprot.skip(ftype)
13989 
      else:
13990 
        iprot.skip(ftype)
13991 
      iprot.readFieldEnd()
13992 
    iprot.readStructEnd()
13993 
 
13994 
  def write(self, oprot):
13995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13997 
      return
13998 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
13999 
    if self.success is not None:
14000 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14001 
      oprot.writeBool(self.success)
14002 
      oprot.writeFieldEnd()
14003 
    if self.ex is not None:
14004 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14005 
      self.ex.write(oprot)
14006 
      oprot.writeFieldEnd()
14007 
    oprot.writeFieldStop()
14008 
    oprot.writeStructEnd()
14009 
 
14010 
  def validate(self):
14011 
    return
14012 
 
14013 
 
14014 
  def __repr__(self):
14015 
    L = ['%s=%r' % (key, value)
14016 
      for key, value in self.__dict__.iteritems()]
14017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14018 
 
14019 
  def __eq__(self, other):
14020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14021 
 
14022 
  def __ne__(self, other):
14023 
    return not (self == other)
14024 
 
14025 
class markOrderDoaRequestAuthorized_args:
14026 
  """
14027 
  Attributes:
14028 
   - orderId
14029 
   - isAuthorized
14030 
  """
14031 
 
14032 
  thrift_spec = (
14033 
    None, # 0
14034 
    (1, TType.I64, 'orderId', None, None, ), # 1
14035 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14036 
  )
14037 
 
14038 
  def __init__(self, orderId=None, isAuthorized=None,):
14039 
    self.orderId = orderId
14040 
    self.isAuthorized = isAuthorized
14041 
 
14042 
  def read(self, iprot):
14043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14045 
      return
14046 
    iprot.readStructBegin()
14047 
    while True:
14048 
      (fname, ftype, fid) = iprot.readFieldBegin()
14049 
      if ftype == TType.STOP:
14050 
        break
14051 
      if fid == 1:
14052 
        if ftype == TType.I64:
14053 
          self.orderId = iprot.readI64();
14054 
        else:
14055 
          iprot.skip(ftype)
14056 
      elif fid == 2:
14057 
        if ftype == TType.BOOL:
14058 
          self.isAuthorized = iprot.readBool();
14059 
        else:
14060 
          iprot.skip(ftype)
14061 
      else:
14062 
        iprot.skip(ftype)
14063 
      iprot.readFieldEnd()
14064 
    iprot.readStructEnd()
14065 
 
14066 
  def write(self, oprot):
14067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14069 
      return
14070 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
14071 
    if self.orderId is not None:
14072 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14073 
      oprot.writeI64(self.orderId)
14074 
      oprot.writeFieldEnd()
14075 
    if self.isAuthorized is not None:
14076 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14077 
      oprot.writeBool(self.isAuthorized)
14078 
      oprot.writeFieldEnd()
14079 
    oprot.writeFieldStop()
14080 
    oprot.writeStructEnd()
14081 
 
14082 
  def validate(self):
14083 
    return
14084 
 
14085 
 
14086 
  def __repr__(self):
14087 
    L = ['%s=%r' % (key, value)
14088 
      for key, value in self.__dict__.iteritems()]
14089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14090 
 
14091 
  def __eq__(self, other):
14092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14093 
 
14094 
  def __ne__(self, other):
14095 
    return not (self == other)
14096 
 
14097 
class markOrderDoaRequestAuthorized_result:
14098 
  """
14099 
  Attributes:
14100 
   - success
14101 
   - ex
14102 
  """
14103 
 
14104 
  thrift_spec = (
14105 
    (0, TType.BOOL, 'success', None, None, ), # 0
14106 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14107 
  )
14108 
 
14109 
  def __init__(self, success=None, ex=None,):
14110 
    self.success = success
14111 
    self.ex = ex
14112 
 
14113 
  def read(self, iprot):
14114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14116 
      return
14117 
    iprot.readStructBegin()
14118 
    while True:
14119 
      (fname, ftype, fid) = iprot.readFieldBegin()
14120 
      if ftype == TType.STOP:
14121 
        break
14122 
      if fid == 0:
14123 
        if ftype == TType.BOOL:
14124 
          self.success = iprot.readBool();
14125 
        else:
14126 
          iprot.skip(ftype)
14127 
      elif fid == 1:
14128 
        if ftype == TType.STRUCT:
14129 
          self.ex = TransactionServiceException()
14130 
          self.ex.read(iprot)
14131 
        else:
14132 
          iprot.skip(ftype)
14133 
      else:
14134 
        iprot.skip(ftype)
14135 
      iprot.readFieldEnd()
14136 
    iprot.readStructEnd()
14137 
 
14138 
  def write(self, oprot):
14139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14141 
      return
14142 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
14143 
    if self.success is not None:
14144 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14145 
      oprot.writeBool(self.success)
14146 
      oprot.writeFieldEnd()
14147 
    if self.ex is not None:
14148 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14149 
      self.ex.write(oprot)
14150 
      oprot.writeFieldEnd()
14151 
    oprot.writeFieldStop()
14152 
    oprot.writeStructEnd()
14153 
 
14154 
  def validate(self):
14155 
    return
14156 
 
14157 
 
14158 
  def __repr__(self):
14159 
    L = ['%s=%r' % (key, value)
14160 
      for key, value in self.__dict__.iteritems()]
14161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14162 
 
14163 
  def __eq__(self, other):
14164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14165 
 
14166 
  def __ne__(self, other):
14167 
    return not (self == other)
14168 
 
4488 rajveer 14169 
class markOrderReturnRequestReceived_args:
14170 
  """
14171 
  Attributes:
14172 
   - orderId
14173 
  """
14174 
 
14175 
  thrift_spec = (
14176 
    None, # 0
14177 
    (1, TType.I64, 'orderId', None, None, ), # 1
14178 
  )
14179 
 
14180 
  def __init__(self, orderId=None,):
14181 
    self.orderId = orderId
14182 
 
14183 
  def read(self, iprot):
14184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14186 
      return
14187 
    iprot.readStructBegin()
14188 
    while True:
14189 
      (fname, ftype, fid) = iprot.readFieldBegin()
14190 
      if ftype == TType.STOP:
14191 
        break
14192 
      if fid == 1:
14193 
        if ftype == TType.I64:
14194 
          self.orderId = iprot.readI64();
14195 
        else:
14196 
          iprot.skip(ftype)
14197 
      else:
14198 
        iprot.skip(ftype)
14199 
      iprot.readFieldEnd()
14200 
    iprot.readStructEnd()
14201 
 
14202 
  def write(self, oprot):
14203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14205 
      return
14206 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
14207 
    if self.orderId is not None:
14208 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14209 
      oprot.writeI64(self.orderId)
14210 
      oprot.writeFieldEnd()
14211 
    oprot.writeFieldStop()
14212 
    oprot.writeStructEnd()
14213 
 
14214 
  def validate(self):
14215 
    return
14216 
 
14217 
 
14218 
  def __repr__(self):
14219 
    L = ['%s=%r' % (key, value)
14220 
      for key, value in self.__dict__.iteritems()]
14221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14222 
 
14223 
  def __eq__(self, other):
14224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14225 
 
14226 
  def __ne__(self, other):
14227 
    return not (self == other)
14228 
 
14229 
class markOrderReturnRequestReceived_result:
14230 
  """
14231 
  Attributes:
14232 
   - success
14233 
   - ex
14234 
  """
14235 
 
14236 
  thrift_spec = (
14237 
    (0, TType.BOOL, 'success', None, None, ), # 0
14238 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14239 
  )
14240 
 
14241 
  def __init__(self, success=None, ex=None,):
14242 
    self.success = success
14243 
    self.ex = ex
14244 
 
14245 
  def read(self, iprot):
14246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14248 
      return
14249 
    iprot.readStructBegin()
14250 
    while True:
14251 
      (fname, ftype, fid) = iprot.readFieldBegin()
14252 
      if ftype == TType.STOP:
14253 
        break
14254 
      if fid == 0:
14255 
        if ftype == TType.BOOL:
14256 
          self.success = iprot.readBool();
14257 
        else:
14258 
          iprot.skip(ftype)
14259 
      elif fid == 1:
14260 
        if ftype == TType.STRUCT:
14261 
          self.ex = TransactionServiceException()
14262 
          self.ex.read(iprot)
14263 
        else:
14264 
          iprot.skip(ftype)
14265 
      else:
14266 
        iprot.skip(ftype)
14267 
      iprot.readFieldEnd()
14268 
    iprot.readStructEnd()
14269 
 
14270 
  def write(self, oprot):
14271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14273 
      return
14274 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
14275 
    if self.success is not None:
14276 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14277 
      oprot.writeBool(self.success)
14278 
      oprot.writeFieldEnd()
14279 
    if self.ex is not None:
14280 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14281 
      self.ex.write(oprot)
14282 
      oprot.writeFieldEnd()
14283 
    oprot.writeFieldStop()
14284 
    oprot.writeStructEnd()
14285 
 
14286 
  def validate(self):
14287 
    return
14288 
 
14289 
 
14290 
  def __repr__(self):
14291 
    L = ['%s=%r' % (key, value)
14292 
      for key, value in self.__dict__.iteritems()]
14293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14294 
 
14295 
  def __eq__(self, other):
14296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14297 
 
14298 
  def __ne__(self, other):
14299 
    return not (self == other)
14300 
 
14301 
class markOrderReturnRequestAuthorized_args:
14302 
  """
14303 
  Attributes:
14304 
   - orderId
14305 
   - isAuthorized
14306 
  """
14307 
 
14308 
  thrift_spec = (
14309 
    None, # 0
14310 
    (1, TType.I64, 'orderId', None, None, ), # 1
14311 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14312 
  )
14313 
 
14314 
  def __init__(self, orderId=None, isAuthorized=None,):
14315 
    self.orderId = orderId
14316 
    self.isAuthorized = isAuthorized
14317 
 
14318 
  def read(self, iprot):
14319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14321 
      return
14322 
    iprot.readStructBegin()
14323 
    while True:
14324 
      (fname, ftype, fid) = iprot.readFieldBegin()
14325 
      if ftype == TType.STOP:
14326 
        break
14327 
      if fid == 1:
14328 
        if ftype == TType.I64:
14329 
          self.orderId = iprot.readI64();
14330 
        else:
14331 
          iprot.skip(ftype)
14332 
      elif fid == 2:
14333 
        if ftype == TType.BOOL:
14334 
          self.isAuthorized = iprot.readBool();
14335 
        else:
14336 
          iprot.skip(ftype)
14337 
      else:
14338 
        iprot.skip(ftype)
14339 
      iprot.readFieldEnd()
14340 
    iprot.readStructEnd()
14341 
 
14342 
  def write(self, oprot):
14343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14345 
      return
14346 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
14347 
    if self.orderId is not None:
14348 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14349 
      oprot.writeI64(self.orderId)
14350 
      oprot.writeFieldEnd()
14351 
    if self.isAuthorized is not None:
14352 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14353 
      oprot.writeBool(self.isAuthorized)
14354 
      oprot.writeFieldEnd()
14355 
    oprot.writeFieldStop()
14356 
    oprot.writeStructEnd()
14357 
 
14358 
  def validate(self):
14359 
    return
14360 
 
14361 
 
14362 
  def __repr__(self):
14363 
    L = ['%s=%r' % (key, value)
14364 
      for key, value in self.__dict__.iteritems()]
14365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14366 
 
14367 
  def __eq__(self, other):
14368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14369 
 
14370 
  def __ne__(self, other):
14371 
    return not (self == other)
14372 
 
14373 
class markOrderReturnRequestAuthorized_result:
14374 
  """
14375 
  Attributes:
14376 
   - success
14377 
   - ex
14378 
  """
14379 
 
14380 
  thrift_spec = (
14381 
    (0, TType.BOOL, 'success', None, None, ), # 0
14382 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14383 
  )
14384 
 
14385 
  def __init__(self, success=None, ex=None,):
14386 
    self.success = success
14387 
    self.ex = ex
14388 
 
14389 
  def read(self, iprot):
14390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14392 
      return
14393 
    iprot.readStructBegin()
14394 
    while True:
14395 
      (fname, ftype, fid) = iprot.readFieldBegin()
14396 
      if ftype == TType.STOP:
14397 
        break
14398 
      if fid == 0:
14399 
        if ftype == TType.BOOL:
14400 
          self.success = iprot.readBool();
14401 
        else:
14402 
          iprot.skip(ftype)
14403 
      elif fid == 1:
14404 
        if ftype == TType.STRUCT:
14405 
          self.ex = TransactionServiceException()
14406 
          self.ex.read(iprot)
14407 
        else:
14408 
          iprot.skip(ftype)
14409 
      else:
14410 
        iprot.skip(ftype)
14411 
      iprot.readFieldEnd()
14412 
    iprot.readStructEnd()
14413 
 
14414 
  def write(self, oprot):
14415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14417 
      return
14418 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
14419 
    if self.success is not None:
14420 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14421 
      oprot.writeBool(self.success)
14422 
      oprot.writeFieldEnd()
14423 
    if self.ex is not None:
14424 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14425 
      self.ex.write(oprot)
14426 
      oprot.writeFieldEnd()
14427 
    oprot.writeFieldStop()
14428 
    oprot.writeStructEnd()
14429 
 
14430 
  def validate(self):
14431 
    return
14432 
 
14433 
 
14434 
  def __repr__(self):
14435 
    L = ['%s=%r' % (key, value)
14436 
      for key, value in self.__dict__.iteritems()]
14437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14438 
 
14439 
  def __eq__(self, other):
14440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14441 
 
14442 
  def __ne__(self, other):
14443 
    return not (self == other)
14444 
 
2536 chandransh 14445 
class requestPickupNumber_args:
14446 
  """
14447 
  Attributes:
14448 
   - orderId
4579 rajveer 14449 
   - providerId
2536 chandransh 14450 
  """
14451 
 
14452 
  thrift_spec = (
14453 
    None, # 0
14454 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 14455 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 14456 
  )
14457 
 
4579 rajveer 14458 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 14459 
    self.orderId = orderId
4579 rajveer 14460 
    self.providerId = providerId
2536 chandransh 14461 
 
14462 
  def read(self, iprot):
14463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14465 
      return
14466 
    iprot.readStructBegin()
14467 
    while True:
14468 
      (fname, ftype, fid) = iprot.readFieldBegin()
14469 
      if ftype == TType.STOP:
14470 
        break
14471 
      if fid == 1:
14472 
        if ftype == TType.I64:
14473 
          self.orderId = iprot.readI64();
14474 
        else:
14475 
          iprot.skip(ftype)
4579 rajveer 14476 
      elif fid == 2:
14477 
        if ftype == TType.I64:
14478 
          self.providerId = iprot.readI64();
14479 
        else:
14480 
          iprot.skip(ftype)
2536 chandransh 14481 
      else:
14482 
        iprot.skip(ftype)
14483 
      iprot.readFieldEnd()
14484 
    iprot.readStructEnd()
14485 
 
14486 
  def write(self, oprot):
14487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14489 
      return
14490 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 14491 
    if self.orderId is not None:
2536 chandransh 14492 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14493 
      oprot.writeI64(self.orderId)
14494 
      oprot.writeFieldEnd()
4579 rajveer 14495 
    if self.providerId is not None:
14496 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
14497 
      oprot.writeI64(self.providerId)
14498 
      oprot.writeFieldEnd()
2536 chandransh 14499 
    oprot.writeFieldStop()
14500 
    oprot.writeStructEnd()
14501 
 
3431 rajveer 14502 
  def validate(self):
14503 
    return
14504 
 
14505 
 
2536 chandransh 14506 
  def __repr__(self):
14507 
    L = ['%s=%r' % (key, value)
14508 
      for key, value in self.__dict__.iteritems()]
14509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14510 
 
14511 
  def __eq__(self, other):
14512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14513 
 
14514 
  def __ne__(self, other):
14515 
    return not (self == other)
14516 
 
14517 
class requestPickupNumber_result:
14518 
  """
14519 
  Attributes:
14520 
   - success
14521 
   - ex
14522 
  """
14523 
 
14524 
  thrift_spec = (
14525 
    (0, TType.BOOL, 'success', None, None, ), # 0
14526 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14527 
  )
14528 
 
14529 
  def __init__(self, success=None, ex=None,):
14530 
    self.success = success
14531 
    self.ex = ex
14532 
 
14533 
  def read(self, iprot):
14534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14536 
      return
14537 
    iprot.readStructBegin()
14538 
    while True:
14539 
      (fname, ftype, fid) = iprot.readFieldBegin()
14540 
      if ftype == TType.STOP:
14541 
        break
14542 
      if fid == 0:
14543 
        if ftype == TType.BOOL:
14544 
          self.success = iprot.readBool();
14545 
        else:
14546 
          iprot.skip(ftype)
14547 
      elif fid == 1:
14548 
        if ftype == TType.STRUCT:
14549 
          self.ex = TransactionServiceException()
14550 
          self.ex.read(iprot)
14551 
        else:
14552 
          iprot.skip(ftype)
14553 
      else:
14554 
        iprot.skip(ftype)
14555 
      iprot.readFieldEnd()
14556 
    iprot.readStructEnd()
14557 
 
14558 
  def write(self, oprot):
14559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14561 
      return
14562 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 14563 
    if self.success is not None:
2536 chandransh 14564 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14565 
      oprot.writeBool(self.success)
14566 
      oprot.writeFieldEnd()
3431 rajveer 14567 
    if self.ex is not None:
2536 chandransh 14568 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14569 
      self.ex.write(oprot)
14570 
      oprot.writeFieldEnd()
14571 
    oprot.writeFieldStop()
14572 
    oprot.writeStructEnd()
14573 
 
3431 rajveer 14574 
  def validate(self):
14575 
    return
14576 
 
14577 
 
2536 chandransh 14578 
  def __repr__(self):
14579 
    L = ['%s=%r' % (key, value)
14580 
      for key, value in self.__dict__.iteritems()]
14581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14582 
 
14583 
  def __eq__(self, other):
14584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14585 
 
14586 
  def __ne__(self, other):
14587 
    return not (self == other)
14588 
 
14589 
class authorizePickup_args:
14590 
  """
14591 
  Attributes:
14592 
   - orderId
14593 
   - pickupNumber
4602 rajveer 14594 
   - providerId
2536 chandransh 14595 
  """
14596 
 
14597 
  thrift_spec = (
14598 
    None, # 0
14599 
    (1, TType.I64, 'orderId', None, None, ), # 1
14600 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 14601 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 14602 
  )
14603 
 
4602 rajveer 14604 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 14605 
    self.orderId = orderId
14606 
    self.pickupNumber = pickupNumber
4602 rajveer 14607 
    self.providerId = providerId
2536 chandransh 14608 
 
14609 
  def read(self, iprot):
14610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14612 
      return
14613 
    iprot.readStructBegin()
14614 
    while True:
14615 
      (fname, ftype, fid) = iprot.readFieldBegin()
14616 
      if ftype == TType.STOP:
14617 
        break
14618 
      if fid == 1:
14619 
        if ftype == TType.I64:
14620 
          self.orderId = iprot.readI64();
14621 
        else:
14622 
          iprot.skip(ftype)
14623 
      elif fid == 2:
14624 
        if ftype == TType.STRING:
14625 
          self.pickupNumber = iprot.readString();
14626 
        else:
14627 
          iprot.skip(ftype)
4602 rajveer 14628 
      elif fid == 3:
14629 
        if ftype == TType.I64:
14630 
          self.providerId = iprot.readI64();
14631 
        else:
14632 
          iprot.skip(ftype)
2536 chandransh 14633 
      else:
14634 
        iprot.skip(ftype)
14635 
      iprot.readFieldEnd()
14636 
    iprot.readStructEnd()
14637 
 
14638 
  def write(self, oprot):
14639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14641 
      return
14642 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 14643 
    if self.orderId is not None:
2536 chandransh 14644 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14645 
      oprot.writeI64(self.orderId)
14646 
      oprot.writeFieldEnd()
3431 rajveer 14647 
    if self.pickupNumber is not None:
2536 chandransh 14648 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
14649 
      oprot.writeString(self.pickupNumber)
14650 
      oprot.writeFieldEnd()
4602 rajveer 14651 
    if self.providerId is not None:
14652 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
14653 
      oprot.writeI64(self.providerId)
14654 
      oprot.writeFieldEnd()
2536 chandransh 14655 
    oprot.writeFieldStop()
14656 
    oprot.writeStructEnd()
14657 
 
3431 rajveer 14658 
  def validate(self):
14659 
    return
14660 
 
14661 
 
2536 chandransh 14662 
  def __repr__(self):
14663 
    L = ['%s=%r' % (key, value)
14664 
      for key, value in self.__dict__.iteritems()]
14665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14666 
 
14667 
  def __eq__(self, other):
14668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14669 
 
14670 
  def __ne__(self, other):
14671 
    return not (self == other)
14672 
 
14673 
class authorizePickup_result:
14674 
  """
14675 
  Attributes:
14676 
   - success
14677 
   - ex
14678 
  """
14679 
 
14680 
  thrift_spec = (
14681 
    (0, TType.BOOL, 'success', None, None, ), # 0
14682 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14683 
  )
14684 
 
14685 
  def __init__(self, success=None, ex=None,):
14686 
    self.success = success
14687 
    self.ex = ex
14688 
 
14689 
  def read(self, iprot):
14690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14692 
      return
14693 
    iprot.readStructBegin()
14694 
    while True:
14695 
      (fname, ftype, fid) = iprot.readFieldBegin()
14696 
      if ftype == TType.STOP:
14697 
        break
14698 
      if fid == 0:
14699 
        if ftype == TType.BOOL:
14700 
          self.success = iprot.readBool();
14701 
        else:
14702 
          iprot.skip(ftype)
14703 
      elif fid == 1:
14704 
        if ftype == TType.STRUCT:
14705 
          self.ex = TransactionServiceException()
14706 
          self.ex.read(iprot)
14707 
        else:
14708 
          iprot.skip(ftype)
14709 
      else:
14710 
        iprot.skip(ftype)
14711 
      iprot.readFieldEnd()
14712 
    iprot.readStructEnd()
14713 
 
14714 
  def write(self, oprot):
14715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14717 
      return
14718 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 14719 
    if self.success is not None:
2536 chandransh 14720 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14721 
      oprot.writeBool(self.success)
14722 
      oprot.writeFieldEnd()
3431 rajveer 14723 
    if self.ex is not None:
2536 chandransh 14724 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14725 
      self.ex.write(oprot)
14726 
      oprot.writeFieldEnd()
14727 
    oprot.writeFieldStop()
14728 
    oprot.writeStructEnd()
14729 
 
3431 rajveer 14730 
  def validate(self):
14731 
    return
14732 
 
14733 
 
2536 chandransh 14734 
  def __repr__(self):
14735 
    L = ['%s=%r' % (key, value)
14736 
      for key, value in self.__dict__.iteritems()]
14737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14738 
 
14739 
  def __eq__(self, other):
14740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14741 
 
14742 
  def __ne__(self, other):
14743 
    return not (self == other)
14744 
 
2764 chandransh 14745 
class markDoasAsPickedUp_args:
14746 
  """
14747 
  Attributes:
14748 
   - providerId
14749 
   - pickupDetails
14750 
  """
14751 
 
14752 
  thrift_spec = (
14753 
    None, # 0
14754 
    (1, TType.I64, 'providerId', None, None, ), # 1
14755 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
14756 
  )
14757 
 
14758 
  def __init__(self, providerId=None, pickupDetails=None,):
14759 
    self.providerId = providerId
14760 
    self.pickupDetails = pickupDetails
14761 
 
14762 
  def read(self, iprot):
14763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14765 
      return
14766 
    iprot.readStructBegin()
14767 
    while True:
14768 
      (fname, ftype, fid) = iprot.readFieldBegin()
14769 
      if ftype == TType.STOP:
14770 
        break
14771 
      if fid == 1:
14772 
        if ftype == TType.I64:
14773 
          self.providerId = iprot.readI64();
14774 
        else:
14775 
          iprot.skip(ftype)
14776 
      elif fid == 2:
14777 
        if ftype == TType.MAP:
14778 
          self.pickupDetails = {}
5031 varun.gupt 14779 
          (_ktype323, _vtype324, _size322 ) = iprot.readMapBegin()
14780 
          for _i326 in xrange(_size322):
14781 
            _key327 = iprot.readString();
14782 
            _val328 = iprot.readString();
14783 
            self.pickupDetails[_key327] = _val328
2764 chandransh 14784 
          iprot.readMapEnd()
14785 
        else:
14786 
          iprot.skip(ftype)
14787 
      else:
14788 
        iprot.skip(ftype)
14789 
      iprot.readFieldEnd()
14790 
    iprot.readStructEnd()
14791 
 
14792 
  def write(self, oprot):
14793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14795 
      return
14796 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 14797 
    if self.providerId is not None:
2764 chandransh 14798 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14799 
      oprot.writeI64(self.providerId)
14800 
      oprot.writeFieldEnd()
3431 rajveer 14801 
    if self.pickupDetails is not None:
2764 chandransh 14802 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14803 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 14804 
      for kiter329,viter330 in self.pickupDetails.items():
14805 
        oprot.writeString(kiter329)
14806 
        oprot.writeString(viter330)
2764 chandransh 14807 
      oprot.writeMapEnd()
14808 
      oprot.writeFieldEnd()
14809 
    oprot.writeFieldStop()
14810 
    oprot.writeStructEnd()
14811 
 
3431 rajveer 14812 
  def validate(self):
14813 
    return
14814 
 
14815 
 
2764 chandransh 14816 
  def __repr__(self):
14817 
    L = ['%s=%r' % (key, value)
14818 
      for key, value in self.__dict__.iteritems()]
14819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14820 
 
14821 
  def __eq__(self, other):
14822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14823 
 
14824 
  def __ne__(self, other):
14825 
    return not (self == other)
14826 
 
14827 
class markDoasAsPickedUp_result:
4910 phani.kuma 14828 
 
14829 
  thrift_spec = (
14830 
  )
14831 
 
14832 
  def read(self, iprot):
14833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14835 
      return
14836 
    iprot.readStructBegin()
14837 
    while True:
14838 
      (fname, ftype, fid) = iprot.readFieldBegin()
14839 
      if ftype == TType.STOP:
14840 
        break
14841 
      else:
14842 
        iprot.skip(ftype)
14843 
      iprot.readFieldEnd()
14844 
    iprot.readStructEnd()
14845 
 
14846 
  def write(self, oprot):
14847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14849 
      return
14850 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
14851 
    oprot.writeFieldStop()
14852 
    oprot.writeStructEnd()
14853 
 
14854 
  def validate(self):
14855 
    return
14856 
 
14857 
 
14858 
  def __repr__(self):
14859 
    L = ['%s=%r' % (key, value)
14860 
      for key, value in self.__dict__.iteritems()]
14861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14862 
 
14863 
  def __eq__(self, other):
14864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14865 
 
14866 
  def __ne__(self, other):
14867 
    return not (self == other)
14868 
 
14869 
class getDoasNotPickedUp_args:
2764 chandransh 14870 
  """
14871 
  Attributes:
4910 phani.kuma 14872 
   - providerId
14873 
  """
14874 
 
14875 
  thrift_spec = (
14876 
    None, # 0
14877 
    (1, TType.I64, 'providerId', None, None, ), # 1
14878 
  )
14879 
 
14880 
  def __init__(self, providerId=None,):
14881 
    self.providerId = providerId
14882 
 
14883 
  def read(self, iprot):
14884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14886 
      return
14887 
    iprot.readStructBegin()
14888 
    while True:
14889 
      (fname, ftype, fid) = iprot.readFieldBegin()
14890 
      if ftype == TType.STOP:
14891 
        break
14892 
      if fid == 1:
14893 
        if ftype == TType.I64:
14894 
          self.providerId = iprot.readI64();
14895 
        else:
14896 
          iprot.skip(ftype)
14897 
      else:
14898 
        iprot.skip(ftype)
14899 
      iprot.readFieldEnd()
14900 
    iprot.readStructEnd()
14901 
 
14902 
  def write(self, oprot):
14903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14905 
      return
14906 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
14907 
    if self.providerId is not None:
14908 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14909 
      oprot.writeI64(self.providerId)
14910 
      oprot.writeFieldEnd()
14911 
    oprot.writeFieldStop()
14912 
    oprot.writeStructEnd()
14913 
 
14914 
  def validate(self):
14915 
    return
14916 
 
14917 
 
14918 
  def __repr__(self):
14919 
    L = ['%s=%r' % (key, value)
14920 
      for key, value in self.__dict__.iteritems()]
14921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14922 
 
14923 
  def __eq__(self, other):
14924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14925 
 
14926 
  def __ne__(self, other):
14927 
    return not (self == other)
14928 
 
14929 
class getDoasNotPickedUp_result:
14930 
  """
14931 
  Attributes:
2764 chandransh 14932 
   - success
14933 
  """
14934 
 
14935 
  thrift_spec = (
14936 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14937 
  )
14938 
 
14939 
  def __init__(self, success=None,):
14940 
    self.success = success
14941 
 
14942 
  def read(self, iprot):
14943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14945 
      return
14946 
    iprot.readStructBegin()
14947 
    while True:
14948 
      (fname, ftype, fid) = iprot.readFieldBegin()
14949 
      if ftype == TType.STOP:
14950 
        break
14951 
      if fid == 0:
14952 
        if ftype == TType.LIST:
14953 
          self.success = []
5031 varun.gupt 14954 
          (_etype334, _size331) = iprot.readListBegin()
14955 
          for _i335 in xrange(_size331):
14956 
            _elem336 = Order()
14957 
            _elem336.read(iprot)
14958 
            self.success.append(_elem336)
2764 chandransh 14959 
          iprot.readListEnd()
14960 
        else:
14961 
          iprot.skip(ftype)
14962 
      else:
14963 
        iprot.skip(ftype)
14964 
      iprot.readFieldEnd()
14965 
    iprot.readStructEnd()
14966 
 
14967 
  def write(self, oprot):
14968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14970 
      return
4910 phani.kuma 14971 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 14972 
    if self.success is not None:
2764 chandransh 14973 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14974 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 14975 
      for iter337 in self.success:
14976 
        iter337.write(oprot)
2764 chandransh 14977 
      oprot.writeListEnd()
14978 
      oprot.writeFieldEnd()
14979 
    oprot.writeFieldStop()
14980 
    oprot.writeStructEnd()
14981 
 
3431 rajveer 14982 
  def validate(self):
14983 
    return
14984 
 
14985 
 
2764 chandransh 14986 
  def __repr__(self):
14987 
    L = ['%s=%r' % (key, value)
14988 
      for key, value in self.__dict__.iteritems()]
14989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14990 
 
14991 
  def __eq__(self, other):
14992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14993 
 
14994 
  def __ne__(self, other):
14995 
    return not (self == other)
14996 
 
4741 phani.kuma 14997 
class markReturnOrdersAsPickedUp_args:
14998 
  """
14999 
  Attributes:
15000 
   - providerId
15001 
   - pickupDetails
15002 
  """
15003 
 
15004 
  thrift_spec = (
15005 
    None, # 0
15006 
    (1, TType.I64, 'providerId', None, None, ), # 1
15007 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
15008 
  )
15009 
 
15010 
  def __init__(self, providerId=None, pickupDetails=None,):
15011 
    self.providerId = providerId
15012 
    self.pickupDetails = pickupDetails
15013 
 
15014 
  def read(self, iprot):
15015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15017 
      return
15018 
    iprot.readStructBegin()
15019 
    while True:
15020 
      (fname, ftype, fid) = iprot.readFieldBegin()
15021 
      if ftype == TType.STOP:
15022 
        break
15023 
      if fid == 1:
15024 
        if ftype == TType.I64:
15025 
          self.providerId = iprot.readI64();
15026 
        else:
15027 
          iprot.skip(ftype)
15028 
      elif fid == 2:
15029 
        if ftype == TType.MAP:
15030 
          self.pickupDetails = {}
5031 varun.gupt 15031 
          (_ktype339, _vtype340, _size338 ) = iprot.readMapBegin()
15032 
          for _i342 in xrange(_size338):
15033 
            _key343 = iprot.readString();
15034 
            _val344 = iprot.readString();
15035 
            self.pickupDetails[_key343] = _val344
4741 phani.kuma 15036 
          iprot.readMapEnd()
15037 
        else:
15038 
          iprot.skip(ftype)
15039 
      else:
15040 
        iprot.skip(ftype)
15041 
      iprot.readFieldEnd()
15042 
    iprot.readStructEnd()
15043 
 
15044 
  def write(self, oprot):
15045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15047 
      return
15048 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
15049 
    if self.providerId is not None:
15050 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15051 
      oprot.writeI64(self.providerId)
15052 
      oprot.writeFieldEnd()
15053 
    if self.pickupDetails is not None:
15054 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15055 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 15056 
      for kiter345,viter346 in self.pickupDetails.items():
15057 
        oprot.writeString(kiter345)
15058 
        oprot.writeString(viter346)
4741 phani.kuma 15059 
      oprot.writeMapEnd()
15060 
      oprot.writeFieldEnd()
15061 
    oprot.writeFieldStop()
15062 
    oprot.writeStructEnd()
15063 
 
15064 
  def validate(self):
15065 
    return
15066 
 
15067 
 
15068 
  def __repr__(self):
15069 
    L = ['%s=%r' % (key, value)
15070 
      for key, value in self.__dict__.iteritems()]
15071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15072 
 
15073 
  def __eq__(self, other):
15074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15075 
 
15076 
  def __ne__(self, other):
15077 
    return not (self == other)
15078 
 
15079 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 15080 
 
15081 
  thrift_spec = (
15082 
  )
15083 
 
15084 
  def read(self, iprot):
15085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15087 
      return
15088 
    iprot.readStructBegin()
15089 
    while True:
15090 
      (fname, ftype, fid) = iprot.readFieldBegin()
15091 
      if ftype == TType.STOP:
15092 
        break
15093 
      else:
15094 
        iprot.skip(ftype)
15095 
      iprot.readFieldEnd()
15096 
    iprot.readStructEnd()
15097 
 
15098 
  def write(self, oprot):
15099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15101 
      return
15102 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
15103 
    oprot.writeFieldStop()
15104 
    oprot.writeStructEnd()
15105 
 
15106 
  def validate(self):
15107 
    return
15108 
 
15109 
 
15110 
  def __repr__(self):
15111 
    L = ['%s=%r' % (key, value)
15112 
      for key, value in self.__dict__.iteritems()]
15113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15114 
 
15115 
  def __eq__(self, other):
15116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15117 
 
15118 
  def __ne__(self, other):
15119 
    return not (self == other)
15120 
 
15121 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 15122 
  """
15123 
  Attributes:
4910 phani.kuma 15124 
   - providerId
15125 
  """
15126 
 
15127 
  thrift_spec = (
15128 
    None, # 0
15129 
    (1, TType.I64, 'providerId', None, None, ), # 1
15130 
  )
15131 
 
15132 
  def __init__(self, providerId=None,):
15133 
    self.providerId = providerId
15134 
 
15135 
  def read(self, iprot):
15136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15138 
      return
15139 
    iprot.readStructBegin()
15140 
    while True:
15141 
      (fname, ftype, fid) = iprot.readFieldBegin()
15142 
      if ftype == TType.STOP:
15143 
        break
15144 
      if fid == 1:
15145 
        if ftype == TType.I64:
15146 
          self.providerId = iprot.readI64();
15147 
        else:
15148 
          iprot.skip(ftype)
15149 
      else:
15150 
        iprot.skip(ftype)
15151 
      iprot.readFieldEnd()
15152 
    iprot.readStructEnd()
15153 
 
15154 
  def write(self, oprot):
15155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15157 
      return
15158 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
15159 
    if self.providerId is not None:
15160 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15161 
      oprot.writeI64(self.providerId)
15162 
      oprot.writeFieldEnd()
15163 
    oprot.writeFieldStop()
15164 
    oprot.writeStructEnd()
15165 
 
15166 
  def validate(self):
15167 
    return
15168 
 
15169 
 
15170 
  def __repr__(self):
15171 
    L = ['%s=%r' % (key, value)
15172 
      for key, value in self.__dict__.iteritems()]
15173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15174 
 
15175 
  def __eq__(self, other):
15176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15177 
 
15178 
  def __ne__(self, other):
15179 
    return not (self == other)
15180 
 
15181 
class getReturnOrdersNotPickedUp_result:
15182 
  """
15183 
  Attributes:
4741 phani.kuma 15184 
   - success
15185 
  """
15186 
 
15187 
  thrift_spec = (
15188 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15189 
  )
15190 
 
15191 
  def __init__(self, success=None,):
15192 
    self.success = success
15193 
 
15194 
  def read(self, iprot):
15195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15197 
      return
15198 
    iprot.readStructBegin()
15199 
    while True:
15200 
      (fname, ftype, fid) = iprot.readFieldBegin()
15201 
      if ftype == TType.STOP:
15202 
        break
15203 
      if fid == 0:
15204 
        if ftype == TType.LIST:
15205 
          self.success = []
5031 varun.gupt 15206 
          (_etype350, _size347) = iprot.readListBegin()
15207 
          for _i351 in xrange(_size347):
15208 
            _elem352 = Order()
15209 
            _elem352.read(iprot)
15210 
            self.success.append(_elem352)
4741 phani.kuma 15211 
          iprot.readListEnd()
15212 
        else:
15213 
          iprot.skip(ftype)
15214 
      else:
15215 
        iprot.skip(ftype)
15216 
      iprot.readFieldEnd()
15217 
    iprot.readStructEnd()
15218 
 
15219 
  def write(self, oprot):
15220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15222 
      return
4910 phani.kuma 15223 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 15224 
    if self.success is not None:
15225 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15226 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 15227 
      for iter353 in self.success:
15228 
        iter353.write(oprot)
4741 phani.kuma 15229 
      oprot.writeListEnd()
15230 
      oprot.writeFieldEnd()
15231 
    oprot.writeFieldStop()
15232 
    oprot.writeStructEnd()
15233 
 
15234 
  def validate(self):
15235 
    return
15236 
 
15237 
 
15238 
  def __repr__(self):
15239 
    L = ['%s=%r' % (key, value)
15240 
      for key, value in self.__dict__.iteritems()]
15241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15242 
 
15243 
  def __eq__(self, other):
15244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15245 
 
15246 
  def __ne__(self, other):
15247 
    return not (self == other)
15248 
 
2616 chandransh 15249 
class receiveReturn_args:
2591 chandransh 15250 
  """
15251 
  Attributes:
15252 
   - orderId
4479 rajveer 15253 
   - receiveCondition
2591 chandransh 15254 
  """
2536 chandransh 15255 
 
2591 chandransh 15256 
  thrift_spec = (
15257 
    None, # 0
15258 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 15259 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 15260 
  )
15261 
 
4479 rajveer 15262 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 15263 
    self.orderId = orderId
4479 rajveer 15264 
    self.receiveCondition = receiveCondition
2591 chandransh 15265 
 
15266 
  def read(self, iprot):
15267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15269 
      return
15270 
    iprot.readStructBegin()
15271 
    while True:
15272 
      (fname, ftype, fid) = iprot.readFieldBegin()
15273 
      if ftype == TType.STOP:
15274 
        break
15275 
      if fid == 1:
15276 
        if ftype == TType.I64:
15277 
          self.orderId = iprot.readI64();
15278 
        else:
15279 
          iprot.skip(ftype)
4479 rajveer 15280 
      elif fid == 2:
15281 
        if ftype == TType.I64:
15282 
          self.receiveCondition = iprot.readI64();
15283 
        else:
15284 
          iprot.skip(ftype)
2591 chandransh 15285 
      else:
15286 
        iprot.skip(ftype)
15287 
      iprot.readFieldEnd()
15288 
    iprot.readStructEnd()
15289 
 
15290 
  def write(self, oprot):
15291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15293 
      return
2616 chandransh 15294 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 15295 
    if self.orderId is not None:
2591 chandransh 15296 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15297 
      oprot.writeI64(self.orderId)
15298 
      oprot.writeFieldEnd()
4479 rajveer 15299 
    if self.receiveCondition is not None:
15300 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
15301 
      oprot.writeI64(self.receiveCondition)
15302 
      oprot.writeFieldEnd()
2591 chandransh 15303 
    oprot.writeFieldStop()
15304 
    oprot.writeStructEnd()
15305 
 
3431 rajveer 15306 
  def validate(self):
15307 
    return
15308 
 
15309 
 
2591 chandransh 15310 
  def __repr__(self):
15311 
    L = ['%s=%r' % (key, value)
15312 
      for key, value in self.__dict__.iteritems()]
15313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15314 
 
15315 
  def __eq__(self, other):
15316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15317 
 
15318 
  def __ne__(self, other):
15319 
    return not (self == other)
15320 
 
2616 chandransh 15321 
class receiveReturn_result:
2591 chandransh 15322 
  """
15323 
  Attributes:
15324 
   - success
15325 
   - ex
15326 
  """
15327 
 
15328 
  thrift_spec = (
15329 
    (0, TType.BOOL, 'success', None, None, ), # 0
15330 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15331 
  )
15332 
 
15333 
  def __init__(self, success=None, ex=None,):
15334 
    self.success = success
15335 
    self.ex = ex
15336 
 
15337 
  def read(self, iprot):
15338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15340 
      return
15341 
    iprot.readStructBegin()
15342 
    while True:
15343 
      (fname, ftype, fid) = iprot.readFieldBegin()
15344 
      if ftype == TType.STOP:
15345 
        break
15346 
      if fid == 0:
15347 
        if ftype == TType.BOOL:
15348 
          self.success = iprot.readBool();
15349 
        else:
15350 
          iprot.skip(ftype)
15351 
      elif fid == 1:
15352 
        if ftype == TType.STRUCT:
15353 
          self.ex = TransactionServiceException()
15354 
          self.ex.read(iprot)
15355 
        else:
15356 
          iprot.skip(ftype)
15357 
      else:
15358 
        iprot.skip(ftype)
15359 
      iprot.readFieldEnd()
15360 
    iprot.readStructEnd()
15361 
 
15362 
  def write(self, oprot):
15363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15365 
      return
2616 chandransh 15366 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 15367 
    if self.success is not None:
2591 chandransh 15368 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15369 
      oprot.writeBool(self.success)
15370 
      oprot.writeFieldEnd()
3431 rajveer 15371 
    if self.ex is not None:
2591 chandransh 15372 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15373 
      self.ex.write(oprot)
15374 
      oprot.writeFieldEnd()
15375 
    oprot.writeFieldStop()
15376 
    oprot.writeStructEnd()
15377 
 
3431 rajveer 15378 
  def validate(self):
15379 
    return
15380 
 
15381 
 
2591 chandransh 15382 
  def __repr__(self):
15383 
    L = ['%s=%r' % (key, value)
15384 
      for key, value in self.__dict__.iteritems()]
15385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15386 
 
15387 
  def __eq__(self, other):
15388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15389 
 
15390 
  def __ne__(self, other):
15391 
    return not (self == other)
15392 
 
15393 
class validateDoa_args:
15394 
  """
15395 
  Attributes:
15396 
   - orderId
15397 
   - isValid
15398 
  """
15399 
 
15400 
  thrift_spec = (
15401 
    None, # 0
15402 
    (1, TType.I64, 'orderId', None, None, ), # 1
15403 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
15404 
  )
15405 
 
15406 
  def __init__(self, orderId=None, isValid=None,):
15407 
    self.orderId = orderId
15408 
    self.isValid = isValid
15409 
 
15410 
  def read(self, iprot):
15411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15413 
      return
15414 
    iprot.readStructBegin()
15415 
    while True:
15416 
      (fname, ftype, fid) = iprot.readFieldBegin()
15417 
      if ftype == TType.STOP:
15418 
        break
15419 
      if fid == 1:
15420 
        if ftype == TType.I64:
15421 
          self.orderId = iprot.readI64();
15422 
        else:
15423 
          iprot.skip(ftype)
15424 
      elif fid == 2:
15425 
        if ftype == TType.BOOL:
15426 
          self.isValid = iprot.readBool();
15427 
        else:
15428 
          iprot.skip(ftype)
15429 
      else:
15430 
        iprot.skip(ftype)
15431 
      iprot.readFieldEnd()
15432 
    iprot.readStructEnd()
15433 
 
15434 
  def write(self, oprot):
15435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15437 
      return
15438 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 15439 
    if self.orderId is not None:
2591 chandransh 15440 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15441 
      oprot.writeI64(self.orderId)
15442 
      oprot.writeFieldEnd()
3431 rajveer 15443 
    if self.isValid is not None:
2591 chandransh 15444 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
15445 
      oprot.writeBool(self.isValid)
15446 
      oprot.writeFieldEnd()
15447 
    oprot.writeFieldStop()
15448 
    oprot.writeStructEnd()
15449 
 
3431 rajveer 15450 
  def validate(self):
15451 
    return
15452 
 
15453 
 
2591 chandransh 15454 
  def __repr__(self):
15455 
    L = ['%s=%r' % (key, value)
15456 
      for key, value in self.__dict__.iteritems()]
15457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15458 
 
15459 
  def __eq__(self, other):
15460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15461 
 
15462 
  def __ne__(self, other):
15463 
    return not (self == other)
15464 
 
15465 
class validateDoa_result:
15466 
  """
15467 
  Attributes:
15468 
   - success
15469 
   - ex
15470 
  """
15471 
 
15472 
  thrift_spec = (
15473 
    (0, TType.BOOL, 'success', None, None, ), # 0
15474 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15475 
  )
15476 
 
15477 
  def __init__(self, success=None, ex=None,):
15478 
    self.success = success
15479 
    self.ex = ex
15480 
 
15481 
  def read(self, iprot):
15482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15484 
      return
15485 
    iprot.readStructBegin()
15486 
    while True:
15487 
      (fname, ftype, fid) = iprot.readFieldBegin()
15488 
      if ftype == TType.STOP:
15489 
        break
15490 
      if fid == 0:
15491 
        if ftype == TType.BOOL:
15492 
          self.success = iprot.readBool();
15493 
        else:
15494 
          iprot.skip(ftype)
15495 
      elif fid == 1:
15496 
        if ftype == TType.STRUCT:
15497 
          self.ex = TransactionServiceException()
15498 
          self.ex.read(iprot)
15499 
        else:
15500 
          iprot.skip(ftype)
15501 
      else:
15502 
        iprot.skip(ftype)
15503 
      iprot.readFieldEnd()
15504 
    iprot.readStructEnd()
15505 
 
15506 
  def write(self, oprot):
15507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15509 
      return
15510 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 15511 
    if self.success is not None:
2591 chandransh 15512 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15513 
      oprot.writeBool(self.success)
15514 
      oprot.writeFieldEnd()
3431 rajveer 15515 
    if self.ex is not None:
2591 chandransh 15516 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15517 
      self.ex.write(oprot)
15518 
      oprot.writeFieldEnd()
15519 
    oprot.writeFieldStop()
15520 
    oprot.writeStructEnd()
15521 
 
3431 rajveer 15522 
  def validate(self):
15523 
    return
15524 
 
15525 
 
2591 chandransh 15526 
  def __repr__(self):
15527 
    L = ['%s=%r' % (key, value)
15528 
      for key, value in self.__dict__.iteritems()]
15529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15530 
 
15531 
  def __eq__(self, other):
15532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15533 
 
15534 
  def __ne__(self, other):
15535 
    return not (self == other)
15536 
 
4495 rajveer 15537 
class validateReturnProduct_args:
15538 
  """
15539 
  Attributes:
15540 
   - orderId
15541 
   - isUsable
15542 
  """
15543 
 
15544 
  thrift_spec = (
15545 
    None, # 0
15546 
    (1, TType.I64, 'orderId', None, None, ), # 1
15547 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
15548 
  )
15549 
 
15550 
  def __init__(self, orderId=None, isUsable=None,):
15551 
    self.orderId = orderId
15552 
    self.isUsable = isUsable
15553 
 
15554 
  def read(self, iprot):
15555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15557 
      return
15558 
    iprot.readStructBegin()
15559 
    while True:
15560 
      (fname, ftype, fid) = iprot.readFieldBegin()
15561 
      if ftype == TType.STOP:
15562 
        break
15563 
      if fid == 1:
15564 
        if ftype == TType.I64:
15565 
          self.orderId = iprot.readI64();
15566 
        else:
15567 
          iprot.skip(ftype)
15568 
      elif fid == 2:
15569 
        if ftype == TType.BOOL:
15570 
          self.isUsable = iprot.readBool();
15571 
        else:
15572 
          iprot.skip(ftype)
15573 
      else:
15574 
        iprot.skip(ftype)
15575 
      iprot.readFieldEnd()
15576 
    iprot.readStructEnd()
15577 
 
15578 
  def write(self, oprot):
15579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15581 
      return
15582 
    oprot.writeStructBegin('validateReturnProduct_args')
15583 
    if self.orderId is not None:
15584 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15585 
      oprot.writeI64(self.orderId)
15586 
      oprot.writeFieldEnd()
15587 
    if self.isUsable is not None:
15588 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
15589 
      oprot.writeBool(self.isUsable)
15590 
      oprot.writeFieldEnd()
15591 
    oprot.writeFieldStop()
15592 
    oprot.writeStructEnd()
15593 
 
15594 
  def validate(self):
15595 
    return
15596 
 
15597 
 
15598 
  def __repr__(self):
15599 
    L = ['%s=%r' % (key, value)
15600 
      for key, value in self.__dict__.iteritems()]
15601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15602 
 
15603 
  def __eq__(self, other):
15604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15605 
 
15606 
  def __ne__(self, other):
15607 
    return not (self == other)
15608 
 
15609 
class validateReturnProduct_result:
15610 
  """
15611 
  Attributes:
15612 
   - success
15613 
   - ex
15614 
  """
15615 
 
15616 
  thrift_spec = (
15617 
    (0, TType.BOOL, 'success', None, None, ), # 0
15618 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15619 
  )
15620 
 
15621 
  def __init__(self, success=None, ex=None,):
15622 
    self.success = success
15623 
    self.ex = ex
15624 
 
15625 
  def read(self, iprot):
15626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15628 
      return
15629 
    iprot.readStructBegin()
15630 
    while True:
15631 
      (fname, ftype, fid) = iprot.readFieldBegin()
15632 
      if ftype == TType.STOP:
15633 
        break
15634 
      if fid == 0:
15635 
        if ftype == TType.BOOL:
15636 
          self.success = iprot.readBool();
15637 
        else:
15638 
          iprot.skip(ftype)
15639 
      elif fid == 1:
15640 
        if ftype == TType.STRUCT:
15641 
          self.ex = TransactionServiceException()
15642 
          self.ex.read(iprot)
15643 
        else:
15644 
          iprot.skip(ftype)
15645 
      else:
15646 
        iprot.skip(ftype)
15647 
      iprot.readFieldEnd()
15648 
    iprot.readStructEnd()
15649 
 
15650 
  def write(self, oprot):
15651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15653 
      return
15654 
    oprot.writeStructBegin('validateReturnProduct_result')
15655 
    if self.success is not None:
15656 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15657 
      oprot.writeBool(self.success)
15658 
      oprot.writeFieldEnd()
15659 
    if self.ex is not None:
15660 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15661 
      self.ex.write(oprot)
15662 
      oprot.writeFieldEnd()
15663 
    oprot.writeFieldStop()
15664 
    oprot.writeStructEnd()
15665 
 
15666 
  def validate(self):
15667 
    return
15668 
 
15669 
 
15670 
  def __repr__(self):
15671 
    L = ['%s=%r' % (key, value)
15672 
      for key, value in self.__dict__.iteritems()]
15673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15674 
 
15675 
  def __eq__(self, other):
15676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15677 
 
15678 
  def __ne__(self, other):
15679 
    return not (self == other)
15680 
 
2616 chandransh 15681 
class reshipOrder_args:
15682 
  """
15683 
  Attributes:
15684 
   - orderId
15685 
  """
2591 chandransh 15686 
 
2616 chandransh 15687 
  thrift_spec = (
15688 
    None, # 0
15689 
    (1, TType.I64, 'orderId', None, None, ), # 1
15690 
  )
15691 
 
15692 
  def __init__(self, orderId=None,):
15693 
    self.orderId = orderId
15694 
 
15695 
  def read(self, iprot):
15696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15698 
      return
15699 
    iprot.readStructBegin()
15700 
    while True:
15701 
      (fname, ftype, fid) = iprot.readFieldBegin()
15702 
      if ftype == TType.STOP:
15703 
        break
15704 
      if fid == 1:
15705 
        if ftype == TType.I64:
15706 
          self.orderId = iprot.readI64();
15707 
        else:
15708 
          iprot.skip(ftype)
15709 
      else:
15710 
        iprot.skip(ftype)
15711 
      iprot.readFieldEnd()
15712 
    iprot.readStructEnd()
15713 
 
15714 
  def write(self, oprot):
15715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15717 
      return
15718 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 15719 
    if self.orderId is not None:
2616 chandransh 15720 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15721 
      oprot.writeI64(self.orderId)
15722 
      oprot.writeFieldEnd()
15723 
    oprot.writeFieldStop()
15724 
    oprot.writeStructEnd()
15725 
 
3431 rajveer 15726 
  def validate(self):
15727 
    return
15728 
 
15729 
 
2616 chandransh 15730 
  def __repr__(self):
15731 
    L = ['%s=%r' % (key, value)
15732 
      for key, value in self.__dict__.iteritems()]
15733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15734 
 
15735 
  def __eq__(self, other):
15736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15737 
 
15738 
  def __ne__(self, other):
15739 
    return not (self == other)
15740 
 
15741 
class reshipOrder_result:
15742 
  """
15743 
  Attributes:
15744 
   - success
15745 
   - ex
15746 
  """
15747 
 
15748 
  thrift_spec = (
15749 
    (0, TType.I64, 'success', None, None, ), # 0
15750 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15751 
  )
15752 
 
15753 
  def __init__(self, success=None, ex=None,):
15754 
    self.success = success
15755 
    self.ex = ex
15756 
 
15757 
  def read(self, iprot):
15758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15760 
      return
15761 
    iprot.readStructBegin()
15762 
    while True:
15763 
      (fname, ftype, fid) = iprot.readFieldBegin()
15764 
      if ftype == TType.STOP:
15765 
        break
15766 
      if fid == 0:
15767 
        if ftype == TType.I64:
15768 
          self.success = iprot.readI64();
15769 
        else:
15770 
          iprot.skip(ftype)
15771 
      elif fid == 1:
15772 
        if ftype == TType.STRUCT:
15773 
          self.ex = TransactionServiceException()
15774 
          self.ex.read(iprot)
15775 
        else:
15776 
          iprot.skip(ftype)
15777 
      else:
15778 
        iprot.skip(ftype)
15779 
      iprot.readFieldEnd()
15780 
    iprot.readStructEnd()
15781 
 
15782 
  def write(self, oprot):
15783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15785 
      return
15786 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 15787 
    if self.success is not None:
2616 chandransh 15788 
      oprot.writeFieldBegin('success', TType.I64, 0)
15789 
      oprot.writeI64(self.success)
15790 
      oprot.writeFieldEnd()
3431 rajveer 15791 
    if self.ex is not None:
2616 chandransh 15792 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15793 
      self.ex.write(oprot)
15794 
      oprot.writeFieldEnd()
15795 
    oprot.writeFieldStop()
15796 
    oprot.writeStructEnd()
15797 
 
3431 rajveer 15798 
  def validate(self):
15799 
    return
15800 
 
15801 
 
2616 chandransh 15802 
  def __repr__(self):
15803 
    L = ['%s=%r' % (key, value)
15804 
      for key, value in self.__dict__.iteritems()]
15805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15806 
 
15807 
  def __eq__(self, other):
15808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15809 
 
15810 
  def __ne__(self, other):
15811 
    return not (self == other)
15812 
 
15813 
class refundOrder_args:
15814 
  """
15815 
  Attributes:
15816 
   - orderId
3226 chandransh 15817 
   - refundedBy
15818 
   - reason
2616 chandransh 15819 
  """
15820 
 
15821 
  thrift_spec = (
15822 
    None, # 0
15823 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 15824 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
15825 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 15826 
  )
15827 
 
3226 chandransh 15828 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 15829 
    self.orderId = orderId
3226 chandransh 15830 
    self.refundedBy = refundedBy
15831 
    self.reason = reason
2616 chandransh 15832 
 
15833 
  def read(self, iprot):
15834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15836 
      return
15837 
    iprot.readStructBegin()
15838 
    while True:
15839 
      (fname, ftype, fid) = iprot.readFieldBegin()
15840 
      if ftype == TType.STOP:
15841 
        break
15842 
      if fid == 1:
15843 
        if ftype == TType.I64:
15844 
          self.orderId = iprot.readI64();
15845 
        else:
15846 
          iprot.skip(ftype)
3226 chandransh 15847 
      elif fid == 2:
15848 
        if ftype == TType.STRING:
15849 
          self.refundedBy = iprot.readString();
15850 
        else:
15851 
          iprot.skip(ftype)
15852 
      elif fid == 3:
15853 
        if ftype == TType.STRING:
15854 
          self.reason = iprot.readString();
15855 
        else:
15856 
          iprot.skip(ftype)
2616 chandransh 15857 
      else:
15858 
        iprot.skip(ftype)
15859 
      iprot.readFieldEnd()
15860 
    iprot.readStructEnd()
15861 
 
15862 
  def write(self, oprot):
15863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15865 
      return
15866 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 15867 
    if self.orderId is not None:
2616 chandransh 15868 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15869 
      oprot.writeI64(self.orderId)
15870 
      oprot.writeFieldEnd()
3431 rajveer 15871 
    if self.refundedBy is not None:
3226 chandransh 15872 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
15873 
      oprot.writeString(self.refundedBy)
15874 
      oprot.writeFieldEnd()
3431 rajveer 15875 
    if self.reason is not None:
3226 chandransh 15876 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
15877 
      oprot.writeString(self.reason)
15878 
      oprot.writeFieldEnd()
2616 chandransh 15879 
    oprot.writeFieldStop()
15880 
    oprot.writeStructEnd()
15881 
 
3431 rajveer 15882 
  def validate(self):
15883 
    return
15884 
 
15885 
 
2616 chandransh 15886 
  def __repr__(self):
15887 
    L = ['%s=%r' % (key, value)
15888 
      for key, value in self.__dict__.iteritems()]
15889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15890 
 
15891 
  def __eq__(self, other):
15892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15893 
 
15894 
  def __ne__(self, other):
15895 
    return not (self == other)
15896 
 
15897 
class refundOrder_result:
15898 
  """
15899 
  Attributes:
15900 
   - success
15901 
   - ex
15902 
  """
15903 
 
15904 
  thrift_spec = (
15905 
    (0, TType.BOOL, 'success', None, None, ), # 0
15906 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15907 
  )
15908 
 
15909 
  def __init__(self, success=None, ex=None,):
15910 
    self.success = success
15911 
    self.ex = ex
15912 
 
15913 
  def read(self, iprot):
15914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15916 
      return
15917 
    iprot.readStructBegin()
15918 
    while True:
15919 
      (fname, ftype, fid) = iprot.readFieldBegin()
15920 
      if ftype == TType.STOP:
15921 
        break
15922 
      if fid == 0:
15923 
        if ftype == TType.BOOL:
15924 
          self.success = iprot.readBool();
15925 
        else:
15926 
          iprot.skip(ftype)
15927 
      elif fid == 1:
15928 
        if ftype == TType.STRUCT:
15929 
          self.ex = TransactionServiceException()
15930 
          self.ex.read(iprot)
15931 
        else:
15932 
          iprot.skip(ftype)
15933 
      else:
15934 
        iprot.skip(ftype)
15935 
      iprot.readFieldEnd()
15936 
    iprot.readStructEnd()
15937 
 
15938 
  def write(self, oprot):
15939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15941 
      return
15942 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 15943 
    if self.success is not None:
2616 chandransh 15944 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15945 
      oprot.writeBool(self.success)
15946 
      oprot.writeFieldEnd()
3431 rajveer 15947 
    if self.ex is not None:
2616 chandransh 15948 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15949 
      self.ex.write(oprot)
15950 
      oprot.writeFieldEnd()
15951 
    oprot.writeFieldStop()
15952 
    oprot.writeStructEnd()
15953 
 
3431 rajveer 15954 
  def validate(self):
15955 
    return
15956 
 
15957 
 
2616 chandransh 15958 
  def __repr__(self):
15959 
    L = ['%s=%r' % (key, value)
15960 
      for key, value in self.__dict__.iteritems()]
15961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15962 
 
15963 
  def __eq__(self, other):
15964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15965 
 
15966 
  def __ne__(self, other):
15967 
    return not (self == other)
15968 
 
2690 chandransh 15969 
class getReturnOrders_args:
15970 
  """
15971 
  Attributes:
15972 
   - warehouseId
15973 
   - fromDate
15974 
   - toDate
15975 
  """
2616 chandransh 15976 
 
2690 chandransh 15977 
  thrift_spec = (
15978 
    None, # 0
15979 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
15980 
    (2, TType.I64, 'fromDate', None, None, ), # 2
15981 
    (3, TType.I64, 'toDate', None, None, ), # 3
15982 
  )
15983 
 
15984 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
15985 
    self.warehouseId = warehouseId
15986 
    self.fromDate = fromDate
15987 
    self.toDate = toDate
15988 
 
15989 
  def read(self, iprot):
15990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15992 
      return
15993 
    iprot.readStructBegin()
15994 
    while True:
15995 
      (fname, ftype, fid) = iprot.readFieldBegin()
15996 
      if ftype == TType.STOP:
15997 
        break
15998 
      if fid == 1:
15999 
        if ftype == TType.I64:
16000 
          self.warehouseId = iprot.readI64();
16001 
        else:
16002 
          iprot.skip(ftype)
16003 
      elif fid == 2:
16004 
        if ftype == TType.I64:
16005 
          self.fromDate = iprot.readI64();
16006 
        else:
16007 
          iprot.skip(ftype)
16008 
      elif fid == 3:
16009 
        if ftype == TType.I64:
16010 
          self.toDate = iprot.readI64();
16011 
        else:
16012 
          iprot.skip(ftype)
16013 
      else:
16014 
        iprot.skip(ftype)
16015 
      iprot.readFieldEnd()
16016 
    iprot.readStructEnd()
16017 
 
16018 
  def write(self, oprot):
16019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16021 
      return
16022 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 16023 
    if self.warehouseId is not None:
2690 chandransh 16024 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
16025 
      oprot.writeI64(self.warehouseId)
16026 
      oprot.writeFieldEnd()
3431 rajveer 16027 
    if self.fromDate is not None:
2690 chandransh 16028 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
16029 
      oprot.writeI64(self.fromDate)
16030 
      oprot.writeFieldEnd()
3431 rajveer 16031 
    if self.toDate is not None:
2690 chandransh 16032 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
16033 
      oprot.writeI64(self.toDate)
16034 
      oprot.writeFieldEnd()
16035 
    oprot.writeFieldStop()
16036 
    oprot.writeStructEnd()
16037 
 
3431 rajveer 16038 
  def validate(self):
16039 
    return
16040 
 
16041 
 
2690 chandransh 16042 
  def __repr__(self):
16043 
    L = ['%s=%r' % (key, value)
16044 
      for key, value in self.__dict__.iteritems()]
16045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16046 
 
16047 
  def __eq__(self, other):
16048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16049 
 
16050 
  def __ne__(self, other):
16051 
    return not (self == other)
16052 
 
16053 
class getReturnOrders_result:
16054 
  """
16055 
  Attributes:
16056 
   - success
16057 
  """
16058 
 
16059 
  thrift_spec = (
16060 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
16061 
  )
16062 
 
16063 
  def __init__(self, success=None,):
16064 
    self.success = success
16065 
 
16066 
  def read(self, iprot):
16067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16069 
      return
16070 
    iprot.readStructBegin()
16071 
    while True:
16072 
      (fname, ftype, fid) = iprot.readFieldBegin()
16073 
      if ftype == TType.STOP:
16074 
        break
16075 
      if fid == 0:
16076 
        if ftype == TType.LIST:
16077 
          self.success = []
5031 varun.gupt 16078 
          (_etype357, _size354) = iprot.readListBegin()
16079 
          for _i358 in xrange(_size354):
16080 
            _elem359 = ReturnOrder()
16081 
            _elem359.read(iprot)
16082 
            self.success.append(_elem359)
2690 chandransh 16083 
          iprot.readListEnd()
16084 
        else:
16085 
          iprot.skip(ftype)
16086 
      else:
16087 
        iprot.skip(ftype)
16088 
      iprot.readFieldEnd()
16089 
    iprot.readStructEnd()
16090 
 
16091 
  def write(self, oprot):
16092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16094 
      return
16095 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 16096 
    if self.success is not None:
2690 chandransh 16097 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16098 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 16099 
      for iter360 in self.success:
16100 
        iter360.write(oprot)
2690 chandransh 16101 
      oprot.writeListEnd()
16102 
      oprot.writeFieldEnd()
16103 
    oprot.writeFieldStop()
16104 
    oprot.writeStructEnd()
16105 
 
3431 rajveer 16106 
  def validate(self):
16107 
    return
16108 
 
16109 
 
2690 chandransh 16110 
  def __repr__(self):
16111 
    L = ['%s=%r' % (key, value)
16112 
      for key, value in self.__dict__.iteritems()]
16113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16114 
 
16115 
  def __eq__(self, other):
16116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16117 
 
16118 
  def __ne__(self, other):
16119 
    return not (self == other)
16120 
 
2700 chandransh 16121 
class getReturnOrder_args:
16122 
  """
16123 
  Attributes:
16124 
   - id
16125 
  """
16126 
 
16127 
  thrift_spec = (
16128 
    None, # 0
16129 
    (1, TType.I64, 'id', None, None, ), # 1
16130 
  )
16131 
 
16132 
  def __init__(self, id=None,):
16133 
    self.id = id
16134 
 
16135 
  def read(self, iprot):
16136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16138 
      return
16139 
    iprot.readStructBegin()
16140 
    while True:
16141 
      (fname, ftype, fid) = iprot.readFieldBegin()
16142 
      if ftype == TType.STOP:
16143 
        break
16144 
      if fid == 1:
16145 
        if ftype == TType.I64:
16146 
          self.id = iprot.readI64();
16147 
        else:
16148 
          iprot.skip(ftype)
16149 
      else:
16150 
        iprot.skip(ftype)
16151 
      iprot.readFieldEnd()
16152 
    iprot.readStructEnd()
16153 
 
16154 
  def write(self, oprot):
16155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16157 
      return
16158 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 16159 
    if self.id is not None:
2700 chandransh 16160 
      oprot.writeFieldBegin('id', TType.I64, 1)
16161 
      oprot.writeI64(self.id)
16162 
      oprot.writeFieldEnd()
16163 
    oprot.writeFieldStop()
16164 
    oprot.writeStructEnd()
16165 
 
3431 rajveer 16166 
  def validate(self):
16167 
    return
16168 
 
16169 
 
2700 chandransh 16170 
  def __repr__(self):
16171 
    L = ['%s=%r' % (key, value)
16172 
      for key, value in self.__dict__.iteritems()]
16173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16174 
 
16175 
  def __eq__(self, other):
16176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16177 
 
16178 
  def __ne__(self, other):
16179 
    return not (self == other)
16180 
 
16181 
class getReturnOrder_result:
16182 
  """
16183 
  Attributes:
16184 
   - success
16185 
   - ex
16186 
  """
16187 
 
16188 
  thrift_spec = (
16189 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
16190 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16191 
  )
16192 
 
16193 
  def __init__(self, success=None, ex=None,):
16194 
    self.success = success
16195 
    self.ex = ex
16196 
 
16197 
  def read(self, iprot):
16198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16200 
      return
16201 
    iprot.readStructBegin()
16202 
    while True:
16203 
      (fname, ftype, fid) = iprot.readFieldBegin()
16204 
      if ftype == TType.STOP:
16205 
        break
16206 
      if fid == 0:
16207 
        if ftype == TType.STRUCT:
16208 
          self.success = ReturnOrder()
16209 
          self.success.read(iprot)
16210 
        else:
16211 
          iprot.skip(ftype)
16212 
      elif fid == 1:
16213 
        if ftype == TType.STRUCT:
16214 
          self.ex = TransactionServiceException()
16215 
          self.ex.read(iprot)
16216 
        else:
16217 
          iprot.skip(ftype)
16218 
      else:
16219 
        iprot.skip(ftype)
16220 
      iprot.readFieldEnd()
16221 
    iprot.readStructEnd()
16222 
 
16223 
  def write(self, oprot):
16224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16226 
      return
16227 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 16228 
    if self.success is not None:
2700 chandransh 16229 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16230 
      self.success.write(oprot)
16231 
      oprot.writeFieldEnd()
3431 rajveer 16232 
    if self.ex is not None:
2700 chandransh 16233 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16234 
      self.ex.write(oprot)
16235 
      oprot.writeFieldEnd()
16236 
    oprot.writeFieldStop()
16237 
    oprot.writeStructEnd()
16238 
 
3431 rajveer 16239 
  def validate(self):
16240 
    return
16241 
 
16242 
 
2700 chandransh 16243 
  def __repr__(self):
16244 
    L = ['%s=%r' % (key, value)
16245 
      for key, value in self.__dict__.iteritems()]
16246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16247 
 
16248 
  def __eq__(self, other):
16249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16250 
 
16251 
  def __ne__(self, other):
16252 
    return not (self == other)
16253 
 
2690 chandransh 16254 
class processReturn_args:
16255 
  """
16256 
  Attributes:
16257 
   - returnOrderId
16258 
  """
16259 
 
16260 
  thrift_spec = (
16261 
    None, # 0
16262 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
16263 
  )
16264 
 
16265 
  def __init__(self, returnOrderId=None,):
16266 
    self.returnOrderId = returnOrderId
16267 
 
16268 
  def read(self, iprot):
16269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16271 
      return
16272 
    iprot.readStructBegin()
16273 
    while True:
16274 
      (fname, ftype, fid) = iprot.readFieldBegin()
16275 
      if ftype == TType.STOP:
16276 
        break
16277 
      if fid == 1:
16278 
        if ftype == TType.I64:
16279 
          self.returnOrderId = iprot.readI64();
16280 
        else:
16281 
          iprot.skip(ftype)
16282 
      else:
16283 
        iprot.skip(ftype)
16284 
      iprot.readFieldEnd()
16285 
    iprot.readStructEnd()
16286 
 
16287 
  def write(self, oprot):
16288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16290 
      return
16291 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 16292 
    if self.returnOrderId is not None:
2690 chandransh 16293 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
16294 
      oprot.writeI64(self.returnOrderId)
16295 
      oprot.writeFieldEnd()
16296 
    oprot.writeFieldStop()
16297 
    oprot.writeStructEnd()
16298 
 
3431 rajveer 16299 
  def validate(self):
16300 
    return
16301 
 
16302 
 
2690 chandransh 16303 
  def __repr__(self):
16304 
    L = ['%s=%r' % (key, value)
16305 
      for key, value in self.__dict__.iteritems()]
16306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16307 
 
16308 
  def __eq__(self, other):
16309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16310 
 
16311 
  def __ne__(self, other):
16312 
    return not (self == other)
16313 
 
16314 
class processReturn_result:
16315 
  """
16316 
  Attributes:
16317 
   - ex
16318 
  """
16319 
 
16320 
  thrift_spec = (
16321 
    None, # 0
16322 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16323 
  )
16324 
 
16325 
  def __init__(self, ex=None,):
16326 
    self.ex = ex
16327 
 
16328 
  def read(self, iprot):
16329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16331 
      return
16332 
    iprot.readStructBegin()
16333 
    while True:
16334 
      (fname, ftype, fid) = iprot.readFieldBegin()
16335 
      if ftype == TType.STOP:
16336 
        break
16337 
      if fid == 1:
16338 
        if ftype == TType.STRUCT:
16339 
          self.ex = TransactionServiceException()
16340 
          self.ex.read(iprot)
16341 
        else:
16342 
          iprot.skip(ftype)
16343 
      else:
16344 
        iprot.skip(ftype)
16345 
      iprot.readFieldEnd()
16346 
    iprot.readStructEnd()
16347 
 
16348 
  def write(self, oprot):
16349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16351 
      return
16352 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 16353 
    if self.ex is not None:
2690 chandransh 16354 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16355 
      self.ex.write(oprot)
16356 
      oprot.writeFieldEnd()
16357 
    oprot.writeFieldStop()
16358 
    oprot.writeStructEnd()
16359 
 
3431 rajveer 16360 
  def validate(self):
16361 
    return
16362 
 
16363 
 
2690 chandransh 16364 
  def __repr__(self):
16365 
    L = ['%s=%r' % (key, value)
16366 
      for key, value in self.__dict__.iteritems()]
16367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16368 
 
16369 
  def __eq__(self, other):
16370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16371 
 
16372 
  def __ne__(self, other):
16373 
    return not (self == other)
16374 
 
3451 chandransh 16375 
class updateWeight_args:
16376 
  """
16377 
  Attributes:
16378 
   - orderId
16379 
   - weight
16380 
  """
16381 
 
16382 
  thrift_spec = (
16383 
    None, # 0
16384 
    (1, TType.I64, 'orderId', None, None, ), # 1
16385 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
16386 
  )
16387 
 
16388 
  def __init__(self, orderId=None, weight=None,):
16389 
    self.orderId = orderId
16390 
    self.weight = weight
16391 
 
16392 
  def read(self, iprot):
16393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16395 
      return
16396 
    iprot.readStructBegin()
16397 
    while True:
16398 
      (fname, ftype, fid) = iprot.readFieldBegin()
16399 
      if ftype == TType.STOP:
16400 
        break
16401 
      if fid == 1:
16402 
        if ftype == TType.I64:
16403 
          self.orderId = iprot.readI64();
16404 
        else:
16405 
          iprot.skip(ftype)
16406 
      elif fid == 2:
16407 
        if ftype == TType.DOUBLE:
16408 
          self.weight = iprot.readDouble();
16409 
        else:
16410 
          iprot.skip(ftype)
16411 
      else:
16412 
        iprot.skip(ftype)
16413 
      iprot.readFieldEnd()
16414 
    iprot.readStructEnd()
16415 
 
16416 
  def write(self, oprot):
16417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16419 
      return
16420 
    oprot.writeStructBegin('updateWeight_args')
16421 
    if self.orderId is not None:
16422 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16423 
      oprot.writeI64(self.orderId)
16424 
      oprot.writeFieldEnd()
16425 
    if self.weight is not None:
16426 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
16427 
      oprot.writeDouble(self.weight)
16428 
      oprot.writeFieldEnd()
16429 
    oprot.writeFieldStop()
16430 
    oprot.writeStructEnd()
16431 
 
16432 
  def validate(self):
16433 
    return
16434 
 
16435 
 
16436 
  def __repr__(self):
16437 
    L = ['%s=%r' % (key, value)
16438 
      for key, value in self.__dict__.iteritems()]
16439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16440 
 
16441 
  def __eq__(self, other):
16442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16443 
 
16444 
  def __ne__(self, other):
16445 
    return not (self == other)
16446 
 
16447 
class updateWeight_result:
16448 
  """
16449 
  Attributes:
16450 
   - success
16451 
   - ex
16452 
  """
16453 
 
16454 
  thrift_spec = (
16455 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16456 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16457 
  )
16458 
 
16459 
  def __init__(self, success=None, ex=None,):
16460 
    self.success = success
16461 
    self.ex = ex
16462 
 
16463 
  def read(self, iprot):
16464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16466 
      return
16467 
    iprot.readStructBegin()
16468 
    while True:
16469 
      (fname, ftype, fid) = iprot.readFieldBegin()
16470 
      if ftype == TType.STOP:
16471 
        break
16472 
      if fid == 0:
16473 
        if ftype == TType.STRUCT:
16474 
          self.success = Order()
16475 
          self.success.read(iprot)
16476 
        else:
16477 
          iprot.skip(ftype)
16478 
      elif fid == 1:
16479 
        if ftype == TType.STRUCT:
16480 
          self.ex = TransactionServiceException()
16481 
          self.ex.read(iprot)
16482 
        else:
16483 
          iprot.skip(ftype)
16484 
      else:
16485 
        iprot.skip(ftype)
16486 
      iprot.readFieldEnd()
16487 
    iprot.readStructEnd()
16488 
 
16489 
  def write(self, oprot):
16490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16492 
      return
16493 
    oprot.writeStructBegin('updateWeight_result')
16494 
    if self.success is not None:
16495 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16496 
      self.success.write(oprot)
16497 
      oprot.writeFieldEnd()
16498 
    if self.ex is not None:
16499 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16500 
      self.ex.write(oprot)
16501 
      oprot.writeFieldEnd()
16502 
    oprot.writeFieldStop()
16503 
    oprot.writeStructEnd()
16504 
 
16505 
  def validate(self):
16506 
    return
16507 
 
16508 
 
16509 
  def __repr__(self):
16510 
    L = ['%s=%r' % (key, value)
16511 
      for key, value in self.__dict__.iteritems()]
16512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16513 
 
16514 
  def __eq__(self, other):
16515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16516 
 
16517 
  def __ne__(self, other):
16518 
    return not (self == other)
3469 chandransh 16519 
 
16520 
class changeItem_args:
16521 
  """
16522 
  Attributes:
16523 
   - orderId
16524 
   - itemId
16525 
  """
16526 
 
16527 
  thrift_spec = (
16528 
    None, # 0
16529 
    (1, TType.I64, 'orderId', None, None, ), # 1
16530 
    (2, TType.I64, 'itemId', None, None, ), # 2
16531 
  )
16532 
 
16533 
  def __init__(self, orderId=None, itemId=None,):
16534 
    self.orderId = orderId
16535 
    self.itemId = itemId
16536 
 
16537 
  def read(self, iprot):
16538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16540 
      return
16541 
    iprot.readStructBegin()
16542 
    while True:
16543 
      (fname, ftype, fid) = iprot.readFieldBegin()
16544 
      if ftype == TType.STOP:
16545 
        break
16546 
      if fid == 1:
16547 
        if ftype == TType.I64:
16548 
          self.orderId = iprot.readI64();
16549 
        else:
16550 
          iprot.skip(ftype)
16551 
      elif fid == 2:
16552 
        if ftype == TType.I64:
16553 
          self.itemId = iprot.readI64();
16554 
        else:
16555 
          iprot.skip(ftype)
16556 
      else:
16557 
        iprot.skip(ftype)
16558 
      iprot.readFieldEnd()
16559 
    iprot.readStructEnd()
16560 
 
16561 
  def write(self, oprot):
16562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16564 
      return
16565 
    oprot.writeStructBegin('changeItem_args')
16566 
    if self.orderId is not None:
16567 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16568 
      oprot.writeI64(self.orderId)
16569 
      oprot.writeFieldEnd()
16570 
    if self.itemId is not None:
16571 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16572 
      oprot.writeI64(self.itemId)
16573 
      oprot.writeFieldEnd()
16574 
    oprot.writeFieldStop()
16575 
    oprot.writeStructEnd()
16576 
 
16577 
  def validate(self):
16578 
    return
16579 
 
16580 
 
16581 
  def __repr__(self):
16582 
    L = ['%s=%r' % (key, value)
16583 
      for key, value in self.__dict__.iteritems()]
16584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16585 
 
16586 
  def __eq__(self, other):
16587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16588 
 
16589 
  def __ne__(self, other):
16590 
    return not (self == other)
16591 
 
16592 
class changeItem_result:
16593 
  """
16594 
  Attributes:
16595 
   - success
16596 
   - ex
16597 
  """
16598 
 
16599 
  thrift_spec = (
16600 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16601 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16602 
  )
16603 
 
16604 
  def __init__(self, success=None, ex=None,):
16605 
    self.success = success
16606 
    self.ex = ex
16607 
 
16608 
  def read(self, iprot):
16609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16611 
      return
16612 
    iprot.readStructBegin()
16613 
    while True:
16614 
      (fname, ftype, fid) = iprot.readFieldBegin()
16615 
      if ftype == TType.STOP:
16616 
        break
16617 
      if fid == 0:
16618 
        if ftype == TType.STRUCT:
16619 
          self.success = Order()
16620 
          self.success.read(iprot)
16621 
        else:
16622 
          iprot.skip(ftype)
16623 
      elif fid == 1:
16624 
        if ftype == TType.STRUCT:
16625 
          self.ex = TransactionServiceException()
16626 
          self.ex.read(iprot)
16627 
        else:
16628 
          iprot.skip(ftype)
16629 
      else:
16630 
        iprot.skip(ftype)
16631 
      iprot.readFieldEnd()
16632 
    iprot.readStructEnd()
16633 
 
16634 
  def write(self, oprot):
16635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16637 
      return
16638 
    oprot.writeStructBegin('changeItem_result')
16639 
    if self.success is not None:
16640 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16641 
      self.success.write(oprot)
16642 
      oprot.writeFieldEnd()
16643 
    if self.ex is not None:
16644 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16645 
      self.ex.write(oprot)
16646 
      oprot.writeFieldEnd()
16647 
    oprot.writeFieldStop()
16648 
    oprot.writeStructEnd()
16649 
 
16650 
  def validate(self):
16651 
    return
16652 
 
16653 
 
16654 
  def __repr__(self):
16655 
    L = ['%s=%r' % (key, value)
16656 
      for key, value in self.__dict__.iteritems()]
16657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16658 
 
16659 
  def __eq__(self, other):
16660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16661 
 
16662 
  def __ne__(self, other):
16663 
    return not (self == other)
16664 
 
16665 
class shiftToWarehouse_args:
16666 
  """
16667 
  Attributes:
16668 
   - orderId
16669 
   - warehouseId
16670 
  """
16671 
 
16672 
  thrift_spec = (
16673 
    None, # 0
16674 
    (1, TType.I64, 'orderId', None, None, ), # 1
16675 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
16676 
  )
16677 
 
16678 
  def __init__(self, orderId=None, warehouseId=None,):
16679 
    self.orderId = orderId
16680 
    self.warehouseId = warehouseId
16681 
 
16682 
  def read(self, iprot):
16683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16685 
      return
16686 
    iprot.readStructBegin()
16687 
    while True:
16688 
      (fname, ftype, fid) = iprot.readFieldBegin()
16689 
      if ftype == TType.STOP:
16690 
        break
16691 
      if fid == 1:
16692 
        if ftype == TType.I64:
16693 
          self.orderId = iprot.readI64();
16694 
        else:
16695 
          iprot.skip(ftype)
16696 
      elif fid == 2:
16697 
        if ftype == TType.I64:
16698 
          self.warehouseId = iprot.readI64();
16699 
        else:
16700 
          iprot.skip(ftype)
16701 
      else:
16702 
        iprot.skip(ftype)
16703 
      iprot.readFieldEnd()
16704 
    iprot.readStructEnd()
16705 
 
16706 
  def write(self, oprot):
16707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16709 
      return
16710 
    oprot.writeStructBegin('shiftToWarehouse_args')
16711 
    if self.orderId is not None:
16712 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16713 
      oprot.writeI64(self.orderId)
16714 
      oprot.writeFieldEnd()
16715 
    if self.warehouseId is not None:
16716 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16717 
      oprot.writeI64(self.warehouseId)
16718 
      oprot.writeFieldEnd()
16719 
    oprot.writeFieldStop()
16720 
    oprot.writeStructEnd()
16721 
 
16722 
  def validate(self):
16723 
    return
16724 
 
16725 
 
16726 
  def __repr__(self):
16727 
    L = ['%s=%r' % (key, value)
16728 
      for key, value in self.__dict__.iteritems()]
16729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16730 
 
16731 
  def __eq__(self, other):
16732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16733 
 
16734 
  def __ne__(self, other):
16735 
    return not (self == other)
16736 
 
16737 
class shiftToWarehouse_result:
16738 
  """
16739 
  Attributes:
16740 
   - success
16741 
   - ex
16742 
  """
16743 
 
16744 
  thrift_spec = (
16745 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16746 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16747 
  )
16748 
 
16749 
  def __init__(self, success=None, ex=None,):
16750 
    self.success = success
16751 
    self.ex = ex
16752 
 
16753 
  def read(self, iprot):
16754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16756 
      return
16757 
    iprot.readStructBegin()
16758 
    while True:
16759 
      (fname, ftype, fid) = iprot.readFieldBegin()
16760 
      if ftype == TType.STOP:
16761 
        break
16762 
      if fid == 0:
16763 
        if ftype == TType.STRUCT:
16764 
          self.success = Order()
16765 
          self.success.read(iprot)
16766 
        else:
16767 
          iprot.skip(ftype)
16768 
      elif fid == 1:
16769 
        if ftype == TType.STRUCT:
16770 
          self.ex = TransactionServiceException()
16771 
          self.ex.read(iprot)
16772 
        else:
16773 
          iprot.skip(ftype)
16774 
      else:
16775 
        iprot.skip(ftype)
16776 
      iprot.readFieldEnd()
16777 
    iprot.readStructEnd()
16778 
 
16779 
  def write(self, oprot):
16780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16782 
      return
16783 
    oprot.writeStructBegin('shiftToWarehouse_result')
16784 
    if self.success is not None:
16785 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16786 
      self.success.write(oprot)
16787 
      oprot.writeFieldEnd()
16788 
    if self.ex is not None:
16789 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16790 
      self.ex.write(oprot)
16791 
      oprot.writeFieldEnd()
16792 
    oprot.writeFieldStop()
16793 
    oprot.writeStructEnd()
16794 
 
16795 
  def validate(self):
16796 
    return
16797 
 
16798 
 
16799 
  def __repr__(self):
16800 
    L = ['%s=%r' % (key, value)
16801 
      for key, value in self.__dict__.iteritems()]
16802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16803 
 
16804 
  def __eq__(self, other):
16805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16806 
 
16807 
  def __ne__(self, other):
16808 
    return not (self == other)
3553 chandransh 16809 
 
16810 
class addDelayReason_args:
16811 
  """
16812 
  Attributes:
16813 
   - orderId
16814 
   - delayReason
3986 chandransh 16815 
   - furtherDelay
4647 rajveer 16816 
   - delayReasonText
3553 chandransh 16817 
  """
16818 
 
16819 
  thrift_spec = (
16820 
    None, # 0
16821 
    (1, TType.I64, 'orderId', None, None, ), # 1
16822 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 16823 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 16824 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 16825 
  )
16826 
 
4647 rajveer 16827 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 16828 
    self.orderId = orderId
16829 
    self.delayReason = delayReason
3986 chandransh 16830 
    self.furtherDelay = furtherDelay
4647 rajveer 16831 
    self.delayReasonText = delayReasonText
3553 chandransh 16832 
 
16833 
  def read(self, iprot):
16834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16836 
      return
16837 
    iprot.readStructBegin()
16838 
    while True:
16839 
      (fname, ftype, fid) = iprot.readFieldBegin()
16840 
      if ftype == TType.STOP:
16841 
        break
16842 
      if fid == 1:
16843 
        if ftype == TType.I64:
16844 
          self.orderId = iprot.readI64();
16845 
        else:
16846 
          iprot.skip(ftype)
16847 
      elif fid == 2:
16848 
        if ftype == TType.I32:
16849 
          self.delayReason = iprot.readI32();
16850 
        else:
16851 
          iprot.skip(ftype)
3986 chandransh 16852 
      elif fid == 3:
16853 
        if ftype == TType.I64:
16854 
          self.furtherDelay = iprot.readI64();
16855 
        else:
16856 
          iprot.skip(ftype)
4647 rajveer 16857 
      elif fid == 4:
16858 
        if ftype == TType.STRING:
16859 
          self.delayReasonText = iprot.readString();
16860 
        else:
16861 
          iprot.skip(ftype)
3553 chandransh 16862 
      else:
16863 
        iprot.skip(ftype)
16864 
      iprot.readFieldEnd()
16865 
    iprot.readStructEnd()
16866 
 
16867 
  def write(self, oprot):
16868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16870 
      return
16871 
    oprot.writeStructBegin('addDelayReason_args')
16872 
    if self.orderId is not None:
16873 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16874 
      oprot.writeI64(self.orderId)
16875 
      oprot.writeFieldEnd()
16876 
    if self.delayReason is not None:
16877 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
16878 
      oprot.writeI32(self.delayReason)
16879 
      oprot.writeFieldEnd()
3986 chandransh 16880 
    if self.furtherDelay is not None:
16881 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
16882 
      oprot.writeI64(self.furtherDelay)
16883 
      oprot.writeFieldEnd()
4647 rajveer 16884 
    if self.delayReasonText is not None:
16885 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
16886 
      oprot.writeString(self.delayReasonText)
16887 
      oprot.writeFieldEnd()
3553 chandransh 16888 
    oprot.writeFieldStop()
16889 
    oprot.writeStructEnd()
16890 
 
16891 
  def validate(self):
16892 
    return
16893 
 
16894 
 
16895 
  def __repr__(self):
16896 
    L = ['%s=%r' % (key, value)
16897 
      for key, value in self.__dict__.iteritems()]
16898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16899 
 
16900 
  def __eq__(self, other):
16901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16902 
 
16903 
  def __ne__(self, other):
16904 
    return not (self == other)
16905 
 
16906 
class addDelayReason_result:
16907 
  """
16908 
  Attributes:
16909 
   - success
16910 
   - ex
16911 
  """
16912 
 
16913 
  thrift_spec = (
16914 
    (0, TType.BOOL, 'success', None, None, ), # 0
16915 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16916 
  )
16917 
 
16918 
  def __init__(self, success=None, ex=None,):
16919 
    self.success = success
16920 
    self.ex = ex
16921 
 
16922 
  def read(self, iprot):
16923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16925 
      return
16926 
    iprot.readStructBegin()
16927 
    while True:
16928 
      (fname, ftype, fid) = iprot.readFieldBegin()
16929 
      if ftype == TType.STOP:
16930 
        break
16931 
      if fid == 0:
16932 
        if ftype == TType.BOOL:
16933 
          self.success = iprot.readBool();
16934 
        else:
16935 
          iprot.skip(ftype)
16936 
      elif fid == 1:
16937 
        if ftype == TType.STRUCT:
16938 
          self.ex = TransactionServiceException()
16939 
          self.ex.read(iprot)
16940 
        else:
16941 
          iprot.skip(ftype)
16942 
      else:
16943 
        iprot.skip(ftype)
16944 
      iprot.readFieldEnd()
16945 
    iprot.readStructEnd()
16946 
 
16947 
  def write(self, oprot):
16948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16950 
      return
16951 
    oprot.writeStructBegin('addDelayReason_result')
16952 
    if self.success is not None:
16953 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16954 
      oprot.writeBool(self.success)
16955 
      oprot.writeFieldEnd()
16956 
    if self.ex is not None:
16957 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16958 
      self.ex.write(oprot)
16959 
      oprot.writeFieldEnd()
16960 
    oprot.writeFieldStop()
16961 
    oprot.writeStructEnd()
16962 
 
16963 
  def validate(self):
16964 
    return
16965 
 
16966 
 
16967 
  def __repr__(self):
16968 
    L = ['%s=%r' % (key, value)
16969 
      for key, value in self.__dict__.iteritems()]
16970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16971 
 
16972 
  def __eq__(self, other):
16973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16974 
 
16975 
  def __ne__(self, other):
16976 
    return not (self == other)
3956 chandransh 16977 
 
16978 
class reconcileCodCollection_args:
16979 
  """
16980 
  Attributes:
16981 
   - collectedAmountMap
16982 
   - xferBy
16983 
   - xferTxnId
16984 
   - xferDate
16985 
  """
16986 
 
16987 
  thrift_spec = (
16988 
    None, # 0
16989 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
16990 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
16991 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
16992 
    (4, TType.I64, 'xferDate', None, None, ), # 4
16993 
  )
16994 
 
16995 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
16996 
    self.collectedAmountMap = collectedAmountMap
16997 
    self.xferBy = xferBy
16998 
    self.xferTxnId = xferTxnId
16999 
    self.xferDate = xferDate
17000 
 
17001 
  def read(self, iprot):
17002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17004 
      return
17005 
    iprot.readStructBegin()
17006 
    while True:
17007 
      (fname, ftype, fid) = iprot.readFieldBegin()
17008 
      if ftype == TType.STOP:
17009 
        break
17010 
      if fid == 1:
17011 
        if ftype == TType.MAP:
17012 
          self.collectedAmountMap = {}
5031 varun.gupt 17013 
          (_ktype362, _vtype363, _size361 ) = iprot.readMapBegin()
17014 
          for _i365 in xrange(_size361):
17015 
            _key366 = iprot.readString();
17016 
            _val367 = iprot.readDouble();
17017 
            self.collectedAmountMap[_key366] = _val367
3956 chandransh 17018 
          iprot.readMapEnd()
17019 
        else:
17020 
          iprot.skip(ftype)
17021 
      elif fid == 2:
17022 
        if ftype == TType.STRING:
17023 
          self.xferBy = iprot.readString();
17024 
        else:
17025 
          iprot.skip(ftype)
17026 
      elif fid == 3:
17027 
        if ftype == TType.STRING:
17028 
          self.xferTxnId = iprot.readString();
17029 
        else:
17030 
          iprot.skip(ftype)
17031 
      elif fid == 4:
17032 
        if ftype == TType.I64:
17033 
          self.xferDate = iprot.readI64();
17034 
        else:
17035 
          iprot.skip(ftype)
17036 
      else:
17037 
        iprot.skip(ftype)
17038 
      iprot.readFieldEnd()
17039 
    iprot.readStructEnd()
17040 
 
17041 
  def write(self, oprot):
17042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17044 
      return
17045 
    oprot.writeStructBegin('reconcileCodCollection_args')
17046 
    if self.collectedAmountMap is not None:
17047 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
17048 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
5031 varun.gupt 17049 
      for kiter368,viter369 in self.collectedAmountMap.items():
17050 
        oprot.writeString(kiter368)
17051 
        oprot.writeDouble(viter369)
3956 chandransh 17052 
      oprot.writeMapEnd()
17053 
      oprot.writeFieldEnd()
17054 
    if self.xferBy is not None:
17055 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
17056 
      oprot.writeString(self.xferBy)
17057 
      oprot.writeFieldEnd()
17058 
    if self.xferTxnId is not None:
17059 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
17060 
      oprot.writeString(self.xferTxnId)
17061 
      oprot.writeFieldEnd()
17062 
    if self.xferDate is not None:
17063 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
17064 
      oprot.writeI64(self.xferDate)
17065 
      oprot.writeFieldEnd()
17066 
    oprot.writeFieldStop()
17067 
    oprot.writeStructEnd()
17068 
 
17069 
  def validate(self):
17070 
    return
17071 
 
17072 
 
17073 
  def __repr__(self):
17074 
    L = ['%s=%r' % (key, value)
17075 
      for key, value in self.__dict__.iteritems()]
17076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17077 
 
17078 
  def __eq__(self, other):
17079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17080 
 
17081 
  def __ne__(self, other):
17082 
    return not (self == other)
17083 
 
17084 
class reconcileCodCollection_result:
17085 
  """
17086 
  Attributes:
17087 
   - success
17088 
   - ex
17089 
  """
17090 
 
17091 
  thrift_spec = (
17092 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
17093 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17094 
  )
17095 
 
17096 
  def __init__(self, success=None, ex=None,):
17097 
    self.success = success
17098 
    self.ex = ex
17099 
 
17100 
  def read(self, iprot):
17101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17103 
      return
17104 
    iprot.readStructBegin()
17105 
    while True:
17106 
      (fname, ftype, fid) = iprot.readFieldBegin()
17107 
      if ftype == TType.STOP:
17108 
        break
17109 
      if fid == 0:
17110 
        if ftype == TType.MAP:
17111 
          self.success = {}
5031 varun.gupt 17112 
          (_ktype371, _vtype372, _size370 ) = iprot.readMapBegin()
17113 
          for _i374 in xrange(_size370):
17114 
            _key375 = iprot.readString();
17115 
            _val376 = iprot.readString();
17116 
            self.success[_key375] = _val376
3956 chandransh 17117 
          iprot.readMapEnd()
17118 
        else:
17119 
          iprot.skip(ftype)
17120 
      elif fid == 1:
17121 
        if ftype == TType.STRUCT:
17122 
          self.ex = TransactionServiceException()
17123 
          self.ex.read(iprot)
17124 
        else:
17125 
          iprot.skip(ftype)
17126 
      else:
17127 
        iprot.skip(ftype)
17128 
      iprot.readFieldEnd()
17129 
    iprot.readStructEnd()
17130 
 
17131 
  def write(self, oprot):
17132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17134 
      return
17135 
    oprot.writeStructBegin('reconcileCodCollection_result')
17136 
    if self.success is not None:
17137 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17138 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
5031 varun.gupt 17139 
      for kiter377,viter378 in self.success.items():
17140 
        oprot.writeString(kiter377)
17141 
        oprot.writeString(viter378)
3956 chandransh 17142 
      oprot.writeMapEnd()
17143 
      oprot.writeFieldEnd()
17144 
    if self.ex is not None:
17145 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17146 
      self.ex.write(oprot)
17147 
      oprot.writeFieldEnd()
17148 
    oprot.writeFieldStop()
17149 
    oprot.writeStructEnd()
17150 
 
17151 
  def validate(self):
17152 
    return
17153 
 
17154 
 
17155 
  def __repr__(self):
17156 
    L = ['%s=%r' % (key, value)
17157 
      for key, value in self.__dict__.iteritems()]
17158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17159 
 
17160 
  def __eq__(self, other):
17161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17162 
 
17163 
  def __ne__(self, other):
17164 
    return not (self == other)
4008 mandeep.dh 17165 
 
17166 
class getTransactionsRequiringExtraProcessing_args:
17167 
  """
17168 
  Attributes:
17169 
   - category
17170 
  """
17171 
 
17172 
  thrift_spec = (
17173 
    None, # 0
17174 
    (1, TType.I32, 'category', None, None, ), # 1
17175 
  )
17176 
 
17177 
  def __init__(self, category=None,):
17178 
    self.category = category
17179 
 
17180 
  def read(self, iprot):
17181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17183 
      return
17184 
    iprot.readStructBegin()
17185 
    while True:
17186 
      (fname, ftype, fid) = iprot.readFieldBegin()
17187 
      if ftype == TType.STOP:
17188 
        break
17189 
      if fid == 1:
17190 
        if ftype == TType.I32:
17191 
          self.category = iprot.readI32();
17192 
        else:
17193 
          iprot.skip(ftype)
17194 
      else:
17195 
        iprot.skip(ftype)
17196 
      iprot.readFieldEnd()
17197 
    iprot.readStructEnd()
17198 
 
17199 
  def write(self, oprot):
17200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17202 
      return
17203 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
17204 
    if self.category is not None:
17205 
      oprot.writeFieldBegin('category', TType.I32, 1)
17206 
      oprot.writeI32(self.category)
17207 
      oprot.writeFieldEnd()
17208 
    oprot.writeFieldStop()
17209 
    oprot.writeStructEnd()
17210 
 
17211 
  def validate(self):
17212 
    return
17213 
 
17214 
 
17215 
  def __repr__(self):
17216 
    L = ['%s=%r' % (key, value)
17217 
      for key, value in self.__dict__.iteritems()]
17218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17219 
 
17220 
  def __eq__(self, other):
17221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17222 
 
17223 
  def __ne__(self, other):
17224 
    return not (self == other)
17225 
 
17226 
class getTransactionsRequiringExtraProcessing_result:
17227 
  """
17228 
  Attributes:
17229 
   - success
17230 
  """
17231 
 
17232 
  thrift_spec = (
17233 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
17234 
  )
17235 
 
17236 
  def __init__(self, success=None,):
17237 
    self.success = success
17238 
 
17239 
  def read(self, iprot):
17240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17242 
      return
17243 
    iprot.readStructBegin()
17244 
    while True:
17245 
      (fname, ftype, fid) = iprot.readFieldBegin()
17246 
      if ftype == TType.STOP:
17247 
        break
17248 
      if fid == 0:
17249 
        if ftype == TType.LIST:
17250 
          self.success = []
5031 varun.gupt 17251 
          (_etype382, _size379) = iprot.readListBegin()
17252 
          for _i383 in xrange(_size379):
17253 
            _elem384 = iprot.readI64();
17254 
            self.success.append(_elem384)
4008 mandeep.dh 17255 
          iprot.readListEnd()
17256 
        else:
17257 
          iprot.skip(ftype)
17258 
      else:
17259 
        iprot.skip(ftype)
17260 
      iprot.readFieldEnd()
17261 
    iprot.readStructEnd()
17262 
 
17263 
  def write(self, oprot):
17264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17266 
      return
17267 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
17268 
    if self.success is not None:
17269 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17270 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 17271 
      for iter385 in self.success:
17272 
        oprot.writeI64(iter385)
4008 mandeep.dh 17273 
      oprot.writeListEnd()
17274 
      oprot.writeFieldEnd()
17275 
    oprot.writeFieldStop()
17276 
    oprot.writeStructEnd()
17277 
 
17278 
  def validate(self):
17279 
    return
17280 
 
17281 
 
17282 
  def __repr__(self):
17283 
    L = ['%s=%r' % (key, value)
17284 
      for key, value in self.__dict__.iteritems()]
17285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17286 
 
17287 
  def __eq__(self, other):
17288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17289 
 
17290 
  def __ne__(self, other):
17291 
    return not (self == other)
17292 
 
17293 
class markTransactionAsProcessed_args:
17294 
  """
17295 
  Attributes:
17296 
   - transactionId
17297 
   - category
17298 
  """
17299 
 
17300 
  thrift_spec = (
17301 
    None, # 0
17302 
    (1, TType.I64, 'transactionId', None, None, ), # 1
17303 
    (2, TType.I32, 'category', None, None, ), # 2
17304 
  )
17305 
 
17306 
  def __init__(self, transactionId=None, category=None,):
17307 
    self.transactionId = transactionId
17308 
    self.category = category
17309 
 
17310 
  def read(self, iprot):
17311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17313 
      return
17314 
    iprot.readStructBegin()
17315 
    while True:
17316 
      (fname, ftype, fid) = iprot.readFieldBegin()
17317 
      if ftype == TType.STOP:
17318 
        break
17319 
      if fid == 1:
17320 
        if ftype == TType.I64:
17321 
          self.transactionId = iprot.readI64();
17322 
        else:
17323 
          iprot.skip(ftype)
17324 
      elif fid == 2:
17325 
        if ftype == TType.I32:
17326 
          self.category = iprot.readI32();
17327 
        else:
17328 
          iprot.skip(ftype)
17329 
      else:
17330 
        iprot.skip(ftype)
17331 
      iprot.readFieldEnd()
17332 
    iprot.readStructEnd()
17333 
 
17334 
  def write(self, oprot):
17335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17337 
      return
17338 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
17339 
    if self.transactionId is not None:
17340 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
17341 
      oprot.writeI64(self.transactionId)
17342 
      oprot.writeFieldEnd()
17343 
    if self.category is not None:
17344 
      oprot.writeFieldBegin('category', TType.I32, 2)
17345 
      oprot.writeI32(self.category)
17346 
      oprot.writeFieldEnd()
17347 
    oprot.writeFieldStop()
17348 
    oprot.writeStructEnd()
17349 
 
17350 
  def validate(self):
17351 
    return
17352 
 
17353 
 
17354 
  def __repr__(self):
17355 
    L = ['%s=%r' % (key, value)
17356 
      for key, value in self.__dict__.iteritems()]
17357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17358 
 
17359 
  def __eq__(self, other):
17360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17361 
 
17362 
  def __ne__(self, other):
17363 
    return not (self == other)
17364 
 
17365 
class markTransactionAsProcessed_result:
17366 
 
17367 
  thrift_spec = (
17368 
  )
17369 
 
17370 
  def read(self, iprot):
17371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17373 
      return
17374 
    iprot.readStructBegin()
17375 
    while True:
17376 
      (fname, ftype, fid) = iprot.readFieldBegin()
17377 
      if ftype == TType.STOP:
17378 
        break
17379 
      else:
17380 
        iprot.skip(ftype)
17381 
      iprot.readFieldEnd()
17382 
    iprot.readStructEnd()
17383 
 
17384 
  def write(self, oprot):
17385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17387 
      return
17388 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
17389 
    oprot.writeFieldStop()
17390 
    oprot.writeStructEnd()
17391 
 
17392 
  def validate(self):
17393 
    return
17394 
 
17395 
 
17396 
  def __repr__(self):
17397 
    L = ['%s=%r' % (key, value)
17398 
      for key, value in self.__dict__.iteritems()]
17399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17400 
 
17401 
  def __eq__(self, other):
17402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17403 
 
17404 
  def __ne__(self, other):
17405 
    return not (self == other)
4018 chandransh 17406 
 
17407 
class getItemWiseRiskyOrdersCount_args:
17408 
 
17409 
  thrift_spec = (
17410 
  )
17411 
 
17412 
  def read(self, iprot):
17413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17415 
      return
17416 
    iprot.readStructBegin()
17417 
    while True:
17418 
      (fname, ftype, fid) = iprot.readFieldBegin()
17419 
      if ftype == TType.STOP:
17420 
        break
17421 
      else:
17422 
        iprot.skip(ftype)
17423 
      iprot.readFieldEnd()
17424 
    iprot.readStructEnd()
17425 
 
17426 
  def write(self, oprot):
17427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17429 
      return
17430 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
17431 
    oprot.writeFieldStop()
17432 
    oprot.writeStructEnd()
17433 
 
17434 
  def validate(self):
17435 
    return
17436 
 
17437 
 
17438 
  def __repr__(self):
17439 
    L = ['%s=%r' % (key, value)
17440 
      for key, value in self.__dict__.iteritems()]
17441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17442 
 
17443 
  def __eq__(self, other):
17444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17445 
 
17446 
  def __ne__(self, other):
17447 
    return not (self == other)
17448 
 
17449 
class getItemWiseRiskyOrdersCount_result:
17450 
  """
17451 
  Attributes:
17452 
   - success
17453 
  """
17454 
 
17455 
  thrift_spec = (
17456 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
17457 
  )
17458 
 
17459 
  def __init__(self, success=None,):
17460 
    self.success = success
17461 
 
17462 
  def read(self, iprot):
17463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17465 
      return
17466 
    iprot.readStructBegin()
17467 
    while True:
17468 
      (fname, ftype, fid) = iprot.readFieldBegin()
17469 
      if ftype == TType.STOP:
17470 
        break
17471 
      if fid == 0:
17472 
        if ftype == TType.MAP:
17473 
          self.success = {}
5031 varun.gupt 17474 
          (_ktype387, _vtype388, _size386 ) = iprot.readMapBegin()
17475 
          for _i390 in xrange(_size386):
17476 
            _key391 = iprot.readI64();
17477 
            _val392 = iprot.readI64();
17478 
            self.success[_key391] = _val392
4018 chandransh 17479 
          iprot.readMapEnd()
17480 
        else:
17481 
          iprot.skip(ftype)
17482 
      else:
17483 
        iprot.skip(ftype)
17484 
      iprot.readFieldEnd()
17485 
    iprot.readStructEnd()
17486 
 
17487 
  def write(self, oprot):
17488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17490 
      return
17491 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
17492 
    if self.success is not None:
17493 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17494 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5031 varun.gupt 17495 
      for kiter393,viter394 in self.success.items():
17496 
        oprot.writeI64(kiter393)
17497 
        oprot.writeI64(viter394)
4018 chandransh 17498 
      oprot.writeMapEnd()
17499 
      oprot.writeFieldEnd()
17500 
    oprot.writeFieldStop()
17501 
    oprot.writeStructEnd()
17502 
 
17503 
  def validate(self):
17504 
    return
17505 
 
17506 
 
17507 
  def __repr__(self):
17508 
    L = ['%s=%r' % (key, value)
17509 
      for key, value in self.__dict__.iteritems()]
17510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17511 
 
17512 
  def __eq__(self, other):
17513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17514 
 
17515 
  def __ne__(self, other):
17516 
    return not (self == other)
4247 rajveer 17517 
 
4295 varun.gupt 17518 
class getOrdersForItemIds_args:
17519 
  """
17520 
  Attributes:
17521 
   - itemIds
17522 
  """
17523 
 
17524 
  thrift_spec = (
17525 
    None, # 0
17526 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
17527 
  )
17528 
 
17529 
  def __init__(self, itemIds=None,):
17530 
    self.itemIds = itemIds
17531 
 
17532 
  def read(self, iprot):
17533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17535 
      return
17536 
    iprot.readStructBegin()
17537 
    while True:
17538 
      (fname, ftype, fid) = iprot.readFieldBegin()
17539 
      if ftype == TType.STOP:
17540 
        break
17541 
      if fid == 1:
17542 
        if ftype == TType.LIST:
17543 
          self.itemIds = []
5031 varun.gupt 17544 
          (_etype398, _size395) = iprot.readListBegin()
17545 
          for _i399 in xrange(_size395):
17546 
            _elem400 = iprot.readI64();
17547 
            self.itemIds.append(_elem400)
4295 varun.gupt 17548 
          iprot.readListEnd()
17549 
        else:
17550 
          iprot.skip(ftype)
17551 
      else:
17552 
        iprot.skip(ftype)
17553 
      iprot.readFieldEnd()
17554 
    iprot.readStructEnd()
17555 
 
17556 
  def write(self, oprot):
17557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17559 
      return
17560 
    oprot.writeStructBegin('getOrdersForItemIds_args')
17561 
    if self.itemIds is not None:
17562 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
17563 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5031 varun.gupt 17564 
      for iter401 in self.itemIds:
17565 
        oprot.writeI64(iter401)
4295 varun.gupt 17566 
      oprot.writeListEnd()
17567 
      oprot.writeFieldEnd()
17568 
    oprot.writeFieldStop()
17569 
    oprot.writeStructEnd()
17570 
 
17571 
  def validate(self):
17572 
    return
17573 
 
17574 
 
17575 
  def __repr__(self):
17576 
    L = ['%s=%r' % (key, value)
17577 
      for key, value in self.__dict__.iteritems()]
17578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17579 
 
17580 
  def __eq__(self, other):
17581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17582 
 
17583 
  def __ne__(self, other):
17584 
    return not (self == other)
17585 
 
17586 
class getOrdersForItemIds_result:
17587 
  """
17588 
  Attributes:
17589 
   - success
17590 
  """
17591 
 
17592 
  thrift_spec = (
17593 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17594 
  )
17595 
 
17596 
  def __init__(self, success=None,):
17597 
    self.success = success
17598 
 
17599 
  def read(self, iprot):
17600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17602 
      return
17603 
    iprot.readStructBegin()
17604 
    while True:
17605 
      (fname, ftype, fid) = iprot.readFieldBegin()
17606 
      if ftype == TType.STOP:
17607 
        break
17608 
      if fid == 0:
17609 
        if ftype == TType.LIST:
17610 
          self.success = []
5031 varun.gupt 17611 
          (_etype405, _size402) = iprot.readListBegin()
17612 
          for _i406 in xrange(_size402):
17613 
            _elem407 = Order()
17614 
            _elem407.read(iprot)
17615 
            self.success.append(_elem407)
4295 varun.gupt 17616 
          iprot.readListEnd()
17617 
        else:
17618 
          iprot.skip(ftype)
17619 
      else:
17620 
        iprot.skip(ftype)
17621 
      iprot.readFieldEnd()
17622 
    iprot.readStructEnd()
17623 
 
17624 
  def write(self, oprot):
17625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17627 
      return
17628 
    oprot.writeStructBegin('getOrdersForItemIds_result')
17629 
    if self.success is not None:
17630 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17631 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 17632 
      for iter408 in self.success:
17633 
        iter408.write(oprot)
4295 varun.gupt 17634 
      oprot.writeListEnd()
17635 
      oprot.writeFieldEnd()
17636 
    oprot.writeFieldStop()
17637 
    oprot.writeStructEnd()
17638 
 
17639 
  def validate(self):
17640 
    return
17641 
 
17642 
 
17643 
  def __repr__(self):
17644 
    L = ['%s=%r' % (key, value)
17645 
      for key, value in self.__dict__.iteritems()]
17646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17647 
 
17648 
  def __eq__(self, other):
17649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17650 
 
17651 
  def __ne__(self, other):
17652 
    return not (self == other)
17653 
 
4247 rajveer 17654 
class markOrderCancellationRequestReceived_args:
17655 
  """
17656 
  Attributes:
17657 
   - orderId
17658 
  """
17659 
 
17660 
  thrift_spec = (
17661 
    None, # 0
17662 
    (1, TType.I64, 'orderId', None, None, ), # 1
17663 
  )
17664 
 
17665 
  def __init__(self, orderId=None,):
17666 
    self.orderId = orderId
17667 
 
17668 
  def read(self, iprot):
17669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17671 
      return
17672 
    iprot.readStructBegin()
17673 
    while True:
17674 
      (fname, ftype, fid) = iprot.readFieldBegin()
17675 
      if ftype == TType.STOP:
17676 
        break
17677 
      if fid == 1:
17678 
        if ftype == TType.I64:
17679 
          self.orderId = iprot.readI64();
17680 
        else:
17681 
          iprot.skip(ftype)
17682 
      else:
17683 
        iprot.skip(ftype)
17684 
      iprot.readFieldEnd()
17685 
    iprot.readStructEnd()
17686 
 
17687 
  def write(self, oprot):
17688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17690 
      return
17691 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
17692 
    if self.orderId is not None:
17693 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17694 
      oprot.writeI64(self.orderId)
17695 
      oprot.writeFieldEnd()
17696 
    oprot.writeFieldStop()
17697 
    oprot.writeStructEnd()
17698 
 
17699 
  def validate(self):
17700 
    return
17701 
 
17702 
 
17703 
  def __repr__(self):
17704 
    L = ['%s=%r' % (key, value)
17705 
      for key, value in self.__dict__.iteritems()]
17706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17707 
 
17708 
  def __eq__(self, other):
17709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17710 
 
17711 
  def __ne__(self, other):
17712 
    return not (self == other)
17713 
 
17714 
class markOrderCancellationRequestReceived_result:
17715 
  """
17716 
  Attributes:
17717 
   - ex
17718 
  """
17719 
 
17720 
  thrift_spec = (
17721 
    None, # 0
17722 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17723 
  )
17724 
 
17725 
  def __init__(self, ex=None,):
17726 
    self.ex = ex
17727 
 
17728 
  def read(self, iprot):
17729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17731 
      return
17732 
    iprot.readStructBegin()
17733 
    while True:
17734 
      (fname, ftype, fid) = iprot.readFieldBegin()
17735 
      if ftype == TType.STOP:
17736 
        break
17737 
      if fid == 1:
17738 
        if ftype == TType.STRUCT:
17739 
          self.ex = TransactionServiceException()
17740 
          self.ex.read(iprot)
17741 
        else:
17742 
          iprot.skip(ftype)
17743 
      else:
17744 
        iprot.skip(ftype)
17745 
      iprot.readFieldEnd()
17746 
    iprot.readStructEnd()
17747 
 
17748 
  def write(self, oprot):
17749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17751 
      return
17752 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
17753 
    if self.ex is not None:
17754 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17755 
      self.ex.write(oprot)
17756 
      oprot.writeFieldEnd()
17757 
    oprot.writeFieldStop()
17758 
    oprot.writeStructEnd()
17759 
 
17760 
  def validate(self):
17761 
    return
17762 
 
17763 
 
17764 
  def __repr__(self):
17765 
    L = ['%s=%r' % (key, value)
17766 
      for key, value in self.__dict__.iteritems()]
17767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17768 
 
17769 
  def __eq__(self, other):
17770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17771 
 
17772 
  def __ne__(self, other):
17773 
    return not (self == other)
17774 
 
17775 
class markOrderCancellationRequestConfirmed_args:
17776 
  """
17777 
  Attributes:
17778 
   - orderId
17779 
  """
17780 
 
17781 
  thrift_spec = (
17782 
    None, # 0
17783 
    (1, TType.I64, 'orderId', None, None, ), # 1
17784 
  )
17785 
 
17786 
  def __init__(self, orderId=None,):
17787 
    self.orderId = orderId
17788 
 
17789 
  def read(self, iprot):
17790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17792 
      return
17793 
    iprot.readStructBegin()
17794 
    while True:
17795 
      (fname, ftype, fid) = iprot.readFieldBegin()
17796 
      if ftype == TType.STOP:
17797 
        break
17798 
      if fid == 1:
17799 
        if ftype == TType.I64:
17800 
          self.orderId = iprot.readI64();
17801 
        else:
17802 
          iprot.skip(ftype)
17803 
      else:
17804 
        iprot.skip(ftype)
17805 
      iprot.readFieldEnd()
17806 
    iprot.readStructEnd()
17807 
 
17808 
  def write(self, oprot):
17809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17811 
      return
17812 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
17813 
    if self.orderId is not None:
17814 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17815 
      oprot.writeI64(self.orderId)
17816 
      oprot.writeFieldEnd()
17817 
    oprot.writeFieldStop()
17818 
    oprot.writeStructEnd()
17819 
 
17820 
  def validate(self):
17821 
    return
17822 
 
17823 
 
17824 
  def __repr__(self):
17825 
    L = ['%s=%r' % (key, value)
17826 
      for key, value in self.__dict__.iteritems()]
17827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17828 
 
17829 
  def __eq__(self, other):
17830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17831 
 
17832 
  def __ne__(self, other):
17833 
    return not (self == other)
17834 
 
17835 
class markOrderCancellationRequestConfirmed_result:
17836 
  """
17837 
  Attributes:
17838 
   - ex
17839 
  """
17840 
 
17841 
  thrift_spec = (
17842 
    None, # 0
17843 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17844 
  )
17845 
 
17846 
  def __init__(self, ex=None,):
17847 
    self.ex = ex
17848 
 
17849 
  def read(self, iprot):
17850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17852 
      return
17853 
    iprot.readStructBegin()
17854 
    while True:
17855 
      (fname, ftype, fid) = iprot.readFieldBegin()
17856 
      if ftype == TType.STOP:
17857 
        break
17858 
      if fid == 1:
17859 
        if ftype == TType.STRUCT:
17860 
          self.ex = TransactionServiceException()
17861 
          self.ex.read(iprot)
17862 
        else:
17863 
          iprot.skip(ftype)
17864 
      else:
17865 
        iprot.skip(ftype)
17866 
      iprot.readFieldEnd()
17867 
    iprot.readStructEnd()
17868 
 
17869 
  def write(self, oprot):
17870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17872 
      return
17873 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
17874 
    if self.ex is not None:
17875 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17876 
      self.ex.write(oprot)
17877 
      oprot.writeFieldEnd()
17878 
    oprot.writeFieldStop()
17879 
    oprot.writeStructEnd()
17880 
 
17881 
  def validate(self):
17882 
    return
17883 
 
17884 
 
17885 
  def __repr__(self):
17886 
    L = ['%s=%r' % (key, value)
17887 
      for key, value in self.__dict__.iteritems()]
17888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17889 
 
17890 
  def __eq__(self, other):
17891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17892 
 
17893 
  def __ne__(self, other):
17894 
    return not (self == other)
17895 
 
17896 
class markOrderCancellationRequestDenied_args:
17897 
  """
17898 
  Attributes:
17899 
   - orderId
17900 
  """
17901 
 
17902 
  thrift_spec = (
17903 
    None, # 0
17904 
    (1, TType.I64, 'orderId', None, None, ), # 1
17905 
  )
17906 
 
17907 
  def __init__(self, orderId=None,):
17908 
    self.orderId = orderId
17909 
 
17910 
  def read(self, iprot):
17911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17913 
      return
17914 
    iprot.readStructBegin()
17915 
    while True:
17916 
      (fname, ftype, fid) = iprot.readFieldBegin()
17917 
      if ftype == TType.STOP:
17918 
        break
17919 
      if fid == 1:
17920 
        if ftype == TType.I64:
17921 
          self.orderId = iprot.readI64();
17922 
        else:
17923 
          iprot.skip(ftype)
17924 
      else:
17925 
        iprot.skip(ftype)
17926 
      iprot.readFieldEnd()
17927 
    iprot.readStructEnd()
17928 
 
17929 
  def write(self, oprot):
17930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17932 
      return
17933 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
17934 
    if self.orderId is not None:
17935 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17936 
      oprot.writeI64(self.orderId)
17937 
      oprot.writeFieldEnd()
17938 
    oprot.writeFieldStop()
17939 
    oprot.writeStructEnd()
17940 
 
17941 
  def validate(self):
17942 
    return
17943 
 
17944 
 
17945 
  def __repr__(self):
17946 
    L = ['%s=%r' % (key, value)
17947 
      for key, value in self.__dict__.iteritems()]
17948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17949 
 
17950 
  def __eq__(self, other):
17951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17952 
 
17953 
  def __ne__(self, other):
17954 
    return not (self == other)
17955 
 
17956 
class markOrderCancellationRequestDenied_result:
17957 
  """
17958 
  Attributes:
17959 
   - ex
17960 
  """
17961 
 
17962 
  thrift_spec = (
17963 
    None, # 0
17964 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17965 
  )
17966 
 
17967 
  def __init__(self, ex=None,):
17968 
    self.ex = ex
17969 
 
17970 
  def read(self, iprot):
17971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17973 
      return
17974 
    iprot.readStructBegin()
17975 
    while True:
17976 
      (fname, ftype, fid) = iprot.readFieldBegin()
17977 
      if ftype == TType.STOP:
17978 
        break
17979 
      if fid == 1:
17980 
        if ftype == TType.STRUCT:
17981 
          self.ex = TransactionServiceException()
17982 
          self.ex.read(iprot)
17983 
        else:
17984 
          iprot.skip(ftype)
17985 
      else:
17986 
        iprot.skip(ftype)
17987 
      iprot.readFieldEnd()
17988 
    iprot.readStructEnd()
17989 
 
17990 
  def write(self, oprot):
17991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17993 
      return
17994 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
17995 
    if self.ex is not None:
17996 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17997 
      self.ex.write(oprot)
17998 
      oprot.writeFieldEnd()
17999 
    oprot.writeFieldStop()
18000 
    oprot.writeStructEnd()
18001 
 
18002 
  def validate(self):
18003 
    return
18004 
 
18005 
 
18006 
  def __repr__(self):
18007 
    L = ['%s=%r' % (key, value)
18008 
      for key, value in self.__dict__.iteritems()]
18009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18010 
 
18011 
  def __eq__(self, other):
18012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18013 
 
18014 
  def __ne__(self, other):
18015 
    return not (self == other)
18016 
 
4258 rajveer 18017 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 18018 
  """
18019 
  Attributes:
4258 rajveer 18020 
   - transactionId
4247 rajveer 18021 
  """
18022 
 
18023 
  thrift_spec = (
18024 
    None, # 0
4258 rajveer 18025 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 18026 
  )
18027 
 
4258 rajveer 18028 
  def __init__(self, transactionId=None,):
18029 
    self.transactionId = transactionId
4247 rajveer 18030 
 
18031 
  def read(self, iprot):
18032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18034 
      return
18035 
    iprot.readStructBegin()
18036 
    while True:
18037 
      (fname, ftype, fid) = iprot.readFieldBegin()
18038 
      if ftype == TType.STOP:
18039 
        break
18040 
      if fid == 1:
18041 
        if ftype == TType.I64:
4258 rajveer 18042 
          self.transactionId = iprot.readI64();
4247 rajveer 18043 
        else:
18044 
          iprot.skip(ftype)
18045 
      else:
18046 
        iprot.skip(ftype)
18047 
      iprot.readFieldEnd()
18048 
    iprot.readStructEnd()
18049 
 
18050 
  def write(self, oprot):
18051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18053 
      return
4258 rajveer 18054 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
18055 
    if self.transactionId is not None:
18056 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18057 
      oprot.writeI64(self.transactionId)
4247 rajveer 18058 
      oprot.writeFieldEnd()
18059 
    oprot.writeFieldStop()
18060 
    oprot.writeStructEnd()
18061 
 
18062 
  def validate(self):
18063 
    return
18064 
 
18065 
 
18066 
  def __repr__(self):
18067 
    L = ['%s=%r' % (key, value)
18068 
      for key, value in self.__dict__.iteritems()]
18069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18070 
 
18071 
  def __eq__(self, other):
18072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18073 
 
18074 
  def __ne__(self, other):
18075 
    return not (self == other)
18076 
 
4258 rajveer 18077 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 18078 
  """
18079 
  Attributes:
18080 
   - ex
18081 
  """
18082 
 
18083 
  thrift_spec = (
18084 
    None, # 0
18085 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18086 
  )
18087 
 
18088 
  def __init__(self, ex=None,):
18089 
    self.ex = ex
18090 
 
18091 
  def read(self, iprot):
18092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18094 
      return
18095 
    iprot.readStructBegin()
18096 
    while True:
18097 
      (fname, ftype, fid) = iprot.readFieldBegin()
18098 
      if ftype == TType.STOP:
18099 
        break
18100 
      if fid == 1:
18101 
        if ftype == TType.STRUCT:
18102 
          self.ex = TransactionServiceException()
18103 
          self.ex.read(iprot)
18104 
        else:
18105 
          iprot.skip(ftype)
18106 
      else:
18107 
        iprot.skip(ftype)
18108 
      iprot.readFieldEnd()
18109 
    iprot.readStructEnd()
18110 
 
18111 
  def write(self, oprot):
18112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18114 
      return
4258 rajveer 18115 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 18116 
    if self.ex is not None:
18117 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18118 
      self.ex.write(oprot)
18119 
      oprot.writeFieldEnd()
18120 
    oprot.writeFieldStop()
18121 
    oprot.writeStructEnd()
18122 
 
18123 
  def validate(self):
18124 
    return
18125 
 
18126 
 
18127 
  def __repr__(self):
18128 
    L = ['%s=%r' % (key, value)
18129 
      for key, value in self.__dict__.iteritems()]
18130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18131 
 
18132 
  def __eq__(self, other):
18133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18134 
 
18135 
  def __ne__(self, other):
18136 
    return not (self == other)
4259 anupam.sin 18137 
 
18138 
class refundTransaction_args:
18139 
  """
18140 
  Attributes:
18141 
   - transactionId
18142 
   - refundedBy
18143 
   - reason
18144 
  """
18145 
 
18146 
  thrift_spec = (
18147 
    None, # 0
18148 
    (1, TType.I64, 'transactionId', None, None, ), # 1
18149 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18150 
    (3, TType.STRING, 'reason', None, None, ), # 3
18151 
  )
18152 
 
18153 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
18154 
    self.transactionId = transactionId
18155 
    self.refundedBy = refundedBy
18156 
    self.reason = reason
18157 
 
18158 
  def read(self, iprot):
18159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18161 
      return
18162 
    iprot.readStructBegin()
18163 
    while True:
18164 
      (fname, ftype, fid) = iprot.readFieldBegin()
18165 
      if ftype == TType.STOP:
18166 
        break
18167 
      if fid == 1:
18168 
        if ftype == TType.I64:
18169 
          self.transactionId = iprot.readI64();
18170 
        else:
18171 
          iprot.skip(ftype)
18172 
      elif fid == 2:
18173 
        if ftype == TType.STRING:
18174 
          self.refundedBy = iprot.readString();
18175 
        else:
18176 
          iprot.skip(ftype)
18177 
      elif fid == 3:
18178 
        if ftype == TType.STRING:
18179 
          self.reason = iprot.readString();
18180 
        else:
18181 
          iprot.skip(ftype)
18182 
      else:
18183 
        iprot.skip(ftype)
18184 
      iprot.readFieldEnd()
18185 
    iprot.readStructEnd()
18186 
 
18187 
  def write(self, oprot):
18188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18190 
      return
18191 
    oprot.writeStructBegin('refundTransaction_args')
18192 
    if self.transactionId is not None:
18193 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18194 
      oprot.writeI64(self.transactionId)
18195 
      oprot.writeFieldEnd()
18196 
    if self.refundedBy is not None:
18197 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18198 
      oprot.writeString(self.refundedBy)
18199 
      oprot.writeFieldEnd()
18200 
    if self.reason is not None:
18201 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18202 
      oprot.writeString(self.reason)
18203 
      oprot.writeFieldEnd()
18204 
    oprot.writeFieldStop()
18205 
    oprot.writeStructEnd()
18206 
 
18207 
  def validate(self):
18208 
    return
18209 
 
18210 
 
18211 
  def __repr__(self):
18212 
    L = ['%s=%r' % (key, value)
18213 
      for key, value in self.__dict__.iteritems()]
18214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18215 
 
18216 
  def __eq__(self, other):
18217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18218 
 
18219 
  def __ne__(self, other):
18220 
    return not (self == other)
18221 
 
18222 
class refundTransaction_result:
18223 
  """
18224 
  Attributes:
18225 
   - ex
18226 
  """
18227 
 
18228 
  thrift_spec = (
18229 
    None, # 0
18230 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18231 
  )
18232 
 
18233 
  def __init__(self, ex=None,):
18234 
    self.ex = ex
18235 
 
18236 
  def read(self, iprot):
18237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18239 
      return
18240 
    iprot.readStructBegin()
18241 
    while True:
18242 
      (fname, ftype, fid) = iprot.readFieldBegin()
18243 
      if ftype == TType.STOP:
18244 
        break
18245 
      if fid == 1:
18246 
        if ftype == TType.STRUCT:
18247 
          self.ex = TransactionServiceException()
18248 
          self.ex.read(iprot)
18249 
        else:
18250 
          iprot.skip(ftype)
18251 
      else:
18252 
        iprot.skip(ftype)
18253 
      iprot.readFieldEnd()
18254 
    iprot.readStructEnd()
18255 
 
18256 
  def write(self, oprot):
18257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18259 
      return
18260 
    oprot.writeStructBegin('refundTransaction_result')
18261 
    if self.ex is not None:
18262 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18263 
      self.ex.write(oprot)
18264 
      oprot.writeFieldEnd()
18265 
    oprot.writeFieldStop()
18266 
    oprot.writeStructEnd()
18267 
 
18268 
  def validate(self):
18269 
    return
18270 
 
18271 
 
18272 
  def __repr__(self):
18273 
    L = ['%s=%r' % (key, value)
18274 
      for key, value in self.__dict__.iteritems()]
18275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18276 
 
18277 
  def __eq__(self, other):
18278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18279 
 
18280 
  def __ne__(self, other):
18281 
    return not (self == other)
4285 rajveer 18282 
 
4324 mandeep.dh 18283 
class updateShipmentAddress_args:
18284 
  """
18285 
  Attributes:
18286 
   - orderId
18287 
   - addressId
18288 
  """
18289 
 
18290 
  thrift_spec = (
18291 
    None, # 0
18292 
    (1, TType.I64, 'orderId', None, None, ), # 1
18293 
    (2, TType.I64, 'addressId', None, None, ), # 2
18294 
  )
18295 
 
18296 
  def __init__(self, orderId=None, addressId=None,):
18297 
    self.orderId = orderId
18298 
    self.addressId = addressId
18299 
 
18300 
  def read(self, iprot):
18301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18303 
      return
18304 
    iprot.readStructBegin()
18305 
    while True:
18306 
      (fname, ftype, fid) = iprot.readFieldBegin()
18307 
      if ftype == TType.STOP:
18308 
        break
18309 
      if fid == 1:
18310 
        if ftype == TType.I64:
18311 
          self.orderId = iprot.readI64();
18312 
        else:
18313 
          iprot.skip(ftype)
18314 
      elif fid == 2:
18315 
        if ftype == TType.I64:
18316 
          self.addressId = iprot.readI64();
18317 
        else:
18318 
          iprot.skip(ftype)
18319 
      else:
18320 
        iprot.skip(ftype)
18321 
      iprot.readFieldEnd()
18322 
    iprot.readStructEnd()
18323 
 
18324 
  def write(self, oprot):
18325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18327 
      return
18328 
    oprot.writeStructBegin('updateShipmentAddress_args')
18329 
    if self.orderId is not None:
18330 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18331 
      oprot.writeI64(self.orderId)
18332 
      oprot.writeFieldEnd()
18333 
    if self.addressId is not None:
18334 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
18335 
      oprot.writeI64(self.addressId)
18336 
      oprot.writeFieldEnd()
18337 
    oprot.writeFieldStop()
18338 
    oprot.writeStructEnd()
18339 
 
18340 
  def validate(self):
18341 
    return
18342 
 
18343 
 
18344 
  def __repr__(self):
18345 
    L = ['%s=%r' % (key, value)
18346 
      for key, value in self.__dict__.iteritems()]
18347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18348 
 
18349 
  def __eq__(self, other):
18350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18351 
 
18352 
  def __ne__(self, other):
18353 
    return not (self == other)
18354 
 
18355 
class updateShipmentAddress_result:
18356 
  """
18357 
  Attributes:
18358 
   - ex
18359 
  """
18360 
 
18361 
  thrift_spec = (
18362 
    None, # 0
18363 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18364 
  )
18365 
 
18366 
  def __init__(self, ex=None,):
18367 
    self.ex = ex
18368 
 
18369 
  def read(self, iprot):
18370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18372 
      return
18373 
    iprot.readStructBegin()
18374 
    while True:
18375 
      (fname, ftype, fid) = iprot.readFieldBegin()
18376 
      if ftype == TType.STOP:
18377 
        break
18378 
      if fid == 1:
18379 
        if ftype == TType.STRUCT:
18380 
          self.ex = TransactionServiceException()
18381 
          self.ex.read(iprot)
18382 
        else:
18383 
          iprot.skip(ftype)
18384 
      else:
18385 
        iprot.skip(ftype)
18386 
      iprot.readFieldEnd()
18387 
    iprot.readStructEnd()
18388 
 
18389 
  def write(self, oprot):
18390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18392 
      return
18393 
    oprot.writeStructBegin('updateShipmentAddress_result')
18394 
    if self.ex is not None:
18395 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18396 
      self.ex.write(oprot)
18397 
      oprot.writeFieldEnd()
18398 
    oprot.writeFieldStop()
18399 
    oprot.writeStructEnd()
18400 
 
18401 
  def validate(self):
18402 
    return
18403 
 
18404 
 
18405 
  def __repr__(self):
18406 
    L = ['%s=%r' % (key, value)
18407 
      for key, value in self.__dict__.iteritems()]
18408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18409 
 
18410 
  def __eq__(self, other):
18411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18412 
 
18413 
  def __ne__(self, other):
18414 
    return not (self == other)
18415 
 
4285 rajveer 18416 
class acceptOrdersForItemId_args:
18417 
  """
18418 
  Attributes:
18419 
   - itemId
18420 
   - inventory
18421 
  """
18422 
 
18423 
  thrift_spec = (
18424 
    None, # 0
18425 
    (1, TType.I64, 'itemId', None, None, ), # 1
18426 
    (2, TType.I64, 'inventory', None, None, ), # 2
18427 
  )
18428 
 
18429 
  def __init__(self, itemId=None, inventory=None,):
18430 
    self.itemId = itemId
18431 
    self.inventory = inventory
18432 
 
18433 
  def read(self, iprot):
18434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18436 
      return
18437 
    iprot.readStructBegin()
18438 
    while True:
18439 
      (fname, ftype, fid) = iprot.readFieldBegin()
18440 
      if ftype == TType.STOP:
18441 
        break
18442 
      if fid == 1:
18443 
        if ftype == TType.I64:
18444 
          self.itemId = iprot.readI64();
18445 
        else:
18446 
          iprot.skip(ftype)
18447 
      elif fid == 2:
18448 
        if ftype == TType.I64:
18449 
          self.inventory = iprot.readI64();
18450 
        else:
18451 
          iprot.skip(ftype)
18452 
      else:
18453 
        iprot.skip(ftype)
18454 
      iprot.readFieldEnd()
18455 
    iprot.readStructEnd()
18456 
 
18457 
  def write(self, oprot):
18458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18460 
      return
18461 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
18462 
    if self.itemId is not None:
18463 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18464 
      oprot.writeI64(self.itemId)
18465 
      oprot.writeFieldEnd()
18466 
    if self.inventory is not None:
18467 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
18468 
      oprot.writeI64(self.inventory)
18469 
      oprot.writeFieldEnd()
18470 
    oprot.writeFieldStop()
18471 
    oprot.writeStructEnd()
18472 
 
18473 
  def validate(self):
18474 
    return
18475 
 
18476 
 
18477 
  def __repr__(self):
18478 
    L = ['%s=%r' % (key, value)
18479 
      for key, value in self.__dict__.iteritems()]
18480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18481 
 
18482 
  def __eq__(self, other):
18483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18484 
 
18485 
  def __ne__(self, other):
18486 
    return not (self == other)
18487 
 
18488 
class acceptOrdersForItemId_result:
18489 
  """
18490 
  Attributes:
18491 
   - success
18492 
   - ex
18493 
  """
18494 
 
18495 
  thrift_spec = (
18496 
    (0, TType.BOOL, 'success', None, None, ), # 0
18497 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18498 
  )
18499 
 
18500 
  def __init__(self, success=None, ex=None,):
18501 
    self.success = success
18502 
    self.ex = ex
18503 
 
18504 
  def read(self, iprot):
18505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18507 
      return
18508 
    iprot.readStructBegin()
18509 
    while True:
18510 
      (fname, ftype, fid) = iprot.readFieldBegin()
18511 
      if ftype == TType.STOP:
18512 
        break
18513 
      if fid == 0:
18514 
        if ftype == TType.BOOL:
18515 
          self.success = iprot.readBool();
18516 
        else:
18517 
          iprot.skip(ftype)
18518 
      elif fid == 1:
18519 
        if ftype == TType.STRUCT:
18520 
          self.ex = TransactionServiceException()
18521 
          self.ex.read(iprot)
18522 
        else:
18523 
          iprot.skip(ftype)
18524 
      else:
18525 
        iprot.skip(ftype)
18526 
      iprot.readFieldEnd()
18527 
    iprot.readStructEnd()
18528 
 
18529 
  def write(self, oprot):
18530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18532 
      return
18533 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
18534 
    if self.success is not None:
18535 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18536 
      oprot.writeBool(self.success)
18537 
      oprot.writeFieldEnd()
18538 
    if self.ex is not None:
18539 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18540 
      self.ex.write(oprot)
18541 
      oprot.writeFieldEnd()
18542 
    oprot.writeFieldStop()
18543 
    oprot.writeStructEnd()
18544 
 
18545 
  def validate(self):
18546 
    return
18547 
 
18548 
 
18549 
  def __repr__(self):
18550 
    L = ['%s=%r' % (key, value)
18551 
      for key, value in self.__dict__.iteritems()]
18552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18553 
 
18554 
  def __eq__(self, other):
18555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18556 
 
18557 
  def __ne__(self, other):
18558 
    return not (self == other)
4303 rajveer 18559 
 
18560 
class markOrdersAsPORaised_args:
18561 
  """
18562 
  Attributes:
18563 
   - vendorId
18564 
   - itemId
18565 
   - quantity
18566 
   - estimate
4369 rajveer 18567 
   - isReminder
4303 rajveer 18568 
  """
18569 
 
18570 
  thrift_spec = (
18571 
    None, # 0
18572 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18573 
    (2, TType.I64, 'itemId', None, None, ), # 2
18574 
    (3, TType.I64, 'quantity', None, None, ), # 3
18575 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18576 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18577 
  )
18578 
 
4369 rajveer 18579 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18580 
    self.vendorId = vendorId
18581 
    self.itemId = itemId
18582 
    self.quantity = quantity
18583 
    self.estimate = estimate
4369 rajveer 18584 
    self.isReminder = isReminder
4303 rajveer 18585 
 
18586 
  def read(self, iprot):
18587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18589 
      return
18590 
    iprot.readStructBegin()
18591 
    while True:
18592 
      (fname, ftype, fid) = iprot.readFieldBegin()
18593 
      if ftype == TType.STOP:
18594 
        break
18595 
      if fid == 1:
18596 
        if ftype == TType.I64:
18597 
          self.vendorId = iprot.readI64();
18598 
        else:
18599 
          iprot.skip(ftype)
18600 
      elif fid == 2:
18601 
        if ftype == TType.I64:
18602 
          self.itemId = iprot.readI64();
18603 
        else:
18604 
          iprot.skip(ftype)
18605 
      elif fid == 3:
18606 
        if ftype == TType.I64:
18607 
          self.quantity = iprot.readI64();
18608 
        else:
18609 
          iprot.skip(ftype)
18610 
      elif fid == 4:
18611 
        if ftype == TType.I64:
18612 
          self.estimate = iprot.readI64();
18613 
        else:
18614 
          iprot.skip(ftype)
4369 rajveer 18615 
      elif fid == 5:
18616 
        if ftype == TType.BOOL:
18617 
          self.isReminder = iprot.readBool();
18618 
        else:
18619 
          iprot.skip(ftype)
4303 rajveer 18620 
      else:
18621 
        iprot.skip(ftype)
18622 
      iprot.readFieldEnd()
18623 
    iprot.readStructEnd()
18624 
 
18625 
  def write(self, oprot):
18626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18628 
      return
18629 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
18630 
    if self.vendorId is not None:
18631 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18632 
      oprot.writeI64(self.vendorId)
18633 
      oprot.writeFieldEnd()
18634 
    if self.itemId is not None:
18635 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18636 
      oprot.writeI64(self.itemId)
18637 
      oprot.writeFieldEnd()
18638 
    if self.quantity is not None:
18639 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18640 
      oprot.writeI64(self.quantity)
18641 
      oprot.writeFieldEnd()
18642 
    if self.estimate is not None:
18643 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18644 
      oprot.writeI64(self.estimate)
18645 
      oprot.writeFieldEnd()
4369 rajveer 18646 
    if self.isReminder is not None:
18647 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18648 
      oprot.writeBool(self.isReminder)
18649 
      oprot.writeFieldEnd()
4303 rajveer 18650 
    oprot.writeFieldStop()
18651 
    oprot.writeStructEnd()
18652 
 
18653 
  def validate(self):
18654 
    return
18655 
 
18656 
 
18657 
  def __repr__(self):
18658 
    L = ['%s=%r' % (key, value)
18659 
      for key, value in self.__dict__.iteritems()]
18660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18661 
 
18662 
  def __eq__(self, other):
18663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18664 
 
18665 
  def __ne__(self, other):
18666 
    return not (self == other)
18667 
 
18668 
class markOrdersAsPORaised_result:
18669 
  """
18670 
  Attributes:
18671 
   - ex
18672 
  """
18673 
 
18674 
  thrift_spec = (
18675 
    None, # 0
18676 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18677 
  )
18678 
 
18679 
  def __init__(self, ex=None,):
18680 
    self.ex = ex
18681 
 
18682 
  def read(self, iprot):
18683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18685 
      return
18686 
    iprot.readStructBegin()
18687 
    while True:
18688 
      (fname, ftype, fid) = iprot.readFieldBegin()
18689 
      if ftype == TType.STOP:
18690 
        break
18691 
      if fid == 1:
18692 
        if ftype == TType.STRUCT:
18693 
          self.ex = TransactionServiceException()
18694 
          self.ex.read(iprot)
18695 
        else:
18696 
          iprot.skip(ftype)
18697 
      else:
18698 
        iprot.skip(ftype)
18699 
      iprot.readFieldEnd()
18700 
    iprot.readStructEnd()
18701 
 
18702 
  def write(self, oprot):
18703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18705 
      return
18706 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
18707 
    if self.ex is not None:
18708 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18709 
      self.ex.write(oprot)
18710 
      oprot.writeFieldEnd()
18711 
    oprot.writeFieldStop()
18712 
    oprot.writeStructEnd()
18713 
 
18714 
  def validate(self):
18715 
    return
18716 
 
18717 
 
18718 
  def __repr__(self):
18719 
    L = ['%s=%r' % (key, value)
18720 
      for key, value in self.__dict__.iteritems()]
18721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18722 
 
18723 
  def __eq__(self, other):
18724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18725 
 
18726 
  def __ne__(self, other):
18727 
    return not (self == other)
18728 
 
18729 
class markOrdersAsReversalInitiated_args:
18730 
  """
18731 
  Attributes:
18732 
   - vendorId
18733 
   - itemId
18734 
   - quantity
18735 
   - estimate
4369 rajveer 18736 
   - isReminder
4303 rajveer 18737 
  """
18738 
 
18739 
  thrift_spec = (
18740 
    None, # 0
18741 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18742 
    (2, TType.I64, 'itemId', None, None, ), # 2
18743 
    (3, TType.I64, 'quantity', None, None, ), # 3
18744 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18745 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18746 
  )
18747 
 
4369 rajveer 18748 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18749 
    self.vendorId = vendorId
18750 
    self.itemId = itemId
18751 
    self.quantity = quantity
18752 
    self.estimate = estimate
4369 rajveer 18753 
    self.isReminder = isReminder
4303 rajveer 18754 
 
18755 
  def read(self, iprot):
18756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18758 
      return
18759 
    iprot.readStructBegin()
18760 
    while True:
18761 
      (fname, ftype, fid) = iprot.readFieldBegin()
18762 
      if ftype == TType.STOP:
18763 
        break
18764 
      if fid == 1:
18765 
        if ftype == TType.I64:
18766 
          self.vendorId = iprot.readI64();
18767 
        else:
18768 
          iprot.skip(ftype)
18769 
      elif fid == 2:
18770 
        if ftype == TType.I64:
18771 
          self.itemId = iprot.readI64();
18772 
        else:
18773 
          iprot.skip(ftype)
18774 
      elif fid == 3:
18775 
        if ftype == TType.I64:
18776 
          self.quantity = iprot.readI64();
18777 
        else:
18778 
          iprot.skip(ftype)
18779 
      elif fid == 4:
18780 
        if ftype == TType.I64:
18781 
          self.estimate = iprot.readI64();
18782 
        else:
18783 
          iprot.skip(ftype)
4369 rajveer 18784 
      elif fid == 5:
18785 
        if ftype == TType.BOOL:
18786 
          self.isReminder = iprot.readBool();
18787 
        else:
18788 
          iprot.skip(ftype)
4303 rajveer 18789 
      else:
18790 
        iprot.skip(ftype)
18791 
      iprot.readFieldEnd()
18792 
    iprot.readStructEnd()
18793 
 
18794 
  def write(self, oprot):
18795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18797 
      return
18798 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
18799 
    if self.vendorId is not None:
18800 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18801 
      oprot.writeI64(self.vendorId)
18802 
      oprot.writeFieldEnd()
18803 
    if self.itemId is not None:
18804 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18805 
      oprot.writeI64(self.itemId)
18806 
      oprot.writeFieldEnd()
18807 
    if self.quantity is not None:
18808 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18809 
      oprot.writeI64(self.quantity)
18810 
      oprot.writeFieldEnd()
18811 
    if self.estimate is not None:
18812 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18813 
      oprot.writeI64(self.estimate)
18814 
      oprot.writeFieldEnd()
4369 rajveer 18815 
    if self.isReminder is not None:
18816 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18817 
      oprot.writeBool(self.isReminder)
18818 
      oprot.writeFieldEnd()
4303 rajveer 18819 
    oprot.writeFieldStop()
18820 
    oprot.writeStructEnd()
18821 
 
18822 
  def validate(self):
18823 
    return
18824 
 
18825 
 
18826 
  def __repr__(self):
18827 
    L = ['%s=%r' % (key, value)
18828 
      for key, value in self.__dict__.iteritems()]
18829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18830 
 
18831 
  def __eq__(self, other):
18832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18833 
 
18834 
  def __ne__(self, other):
18835 
    return not (self == other)
18836 
 
18837 
class markOrdersAsReversalInitiated_result:
18838 
  """
18839 
  Attributes:
18840 
   - ex
18841 
  """
18842 
 
18843 
  thrift_spec = (
18844 
    None, # 0
18845 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18846 
  )
18847 
 
18848 
  def __init__(self, ex=None,):
18849 
    self.ex = ex
18850 
 
18851 
  def read(self, iprot):
18852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18854 
      return
18855 
    iprot.readStructBegin()
18856 
    while True:
18857 
      (fname, ftype, fid) = iprot.readFieldBegin()
18858 
      if ftype == TType.STOP:
18859 
        break
18860 
      if fid == 1:
18861 
        if ftype == TType.STRUCT:
18862 
          self.ex = TransactionServiceException()
18863 
          self.ex.read(iprot)
18864 
        else:
18865 
          iprot.skip(ftype)
18866 
      else:
18867 
        iprot.skip(ftype)
18868 
      iprot.readFieldEnd()
18869 
    iprot.readStructEnd()
18870 
 
18871 
  def write(self, oprot):
18872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18874 
      return
18875 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
18876 
    if self.ex is not None:
18877 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18878 
      self.ex.write(oprot)
18879 
      oprot.writeFieldEnd()
18880 
    oprot.writeFieldStop()
18881 
    oprot.writeStructEnd()
18882 
 
18883 
  def validate(self):
18884 
    return
18885 
 
18886 
 
18887 
  def __repr__(self):
18888 
    L = ['%s=%r' % (key, value)
18889 
      for key, value in self.__dict__.iteritems()]
18890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18891 
 
18892 
  def __eq__(self, other):
18893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18894 
 
18895 
  def __ne__(self, other):
18896 
    return not (self == other)
18897 
 
18898 
class markOrdersAsNotAvailabke_args:
18899 
  """
18900 
  Attributes:
18901 
   - vendorId
18902 
   - itemId
18903 
   - quantity
18904 
   - estimate
4369 rajveer 18905 
   - isReminder
4303 rajveer 18906 
  """
18907 
 
18908 
  thrift_spec = (
18909 
    None, # 0
18910 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18911 
    (2, TType.I64, 'itemId', None, None, ), # 2
18912 
    (3, TType.I64, 'quantity', None, None, ), # 3
18913 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18914 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18915 
  )
18916 
 
4369 rajveer 18917 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18918 
    self.vendorId = vendorId
18919 
    self.itemId = itemId
18920 
    self.quantity = quantity
18921 
    self.estimate = estimate
4369 rajveer 18922 
    self.isReminder = isReminder
4303 rajveer 18923 
 
18924 
  def read(self, iprot):
18925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18927 
      return
18928 
    iprot.readStructBegin()
18929 
    while True:
18930 
      (fname, ftype, fid) = iprot.readFieldBegin()
18931 
      if ftype == TType.STOP:
18932 
        break
18933 
      if fid == 1:
18934 
        if ftype == TType.I64:
18935 
          self.vendorId = iprot.readI64();
18936 
        else:
18937 
          iprot.skip(ftype)
18938 
      elif fid == 2:
18939 
        if ftype == TType.I64:
18940 
          self.itemId = iprot.readI64();
18941 
        else:
18942 
          iprot.skip(ftype)
18943 
      elif fid == 3:
18944 
        if ftype == TType.I64:
18945 
          self.quantity = iprot.readI64();
18946 
        else:
18947 
          iprot.skip(ftype)
18948 
      elif fid == 4:
18949 
        if ftype == TType.I64:
18950 
          self.estimate = iprot.readI64();
18951 
        else:
18952 
          iprot.skip(ftype)
4369 rajveer 18953 
      elif fid == 5:
18954 
        if ftype == TType.BOOL:
18955 
          self.isReminder = iprot.readBool();
18956 
        else:
18957 
          iprot.skip(ftype)
4303 rajveer 18958 
      else:
18959 
        iprot.skip(ftype)
18960 
      iprot.readFieldEnd()
18961 
    iprot.readStructEnd()
18962 
 
18963 
  def write(self, oprot):
18964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18966 
      return
18967 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
18968 
    if self.vendorId is not None:
18969 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18970 
      oprot.writeI64(self.vendorId)
18971 
      oprot.writeFieldEnd()
18972 
    if self.itemId is not None:
18973 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18974 
      oprot.writeI64(self.itemId)
18975 
      oprot.writeFieldEnd()
18976 
    if self.quantity is not None:
18977 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18978 
      oprot.writeI64(self.quantity)
18979 
      oprot.writeFieldEnd()
18980 
    if self.estimate is not None:
18981 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18982 
      oprot.writeI64(self.estimate)
18983 
      oprot.writeFieldEnd()
4369 rajveer 18984 
    if self.isReminder is not None:
18985 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18986 
      oprot.writeBool(self.isReminder)
18987 
      oprot.writeFieldEnd()
4303 rajveer 18988 
    oprot.writeFieldStop()
18989 
    oprot.writeStructEnd()
18990 
 
18991 
  def validate(self):
18992 
    return
18993 
 
18994 
 
18995 
  def __repr__(self):
18996 
    L = ['%s=%r' % (key, value)
18997 
      for key, value in self.__dict__.iteritems()]
18998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18999 
 
19000 
  def __eq__(self, other):
19001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19002 
 
19003 
  def __ne__(self, other):
19004 
    return not (self == other)
19005 
 
19006 
class markOrdersAsNotAvailabke_result:
19007 
  """
19008 
  Attributes:
19009 
   - ex
19010 
  """
19011 
 
19012 
  thrift_spec = (
19013 
    None, # 0
19014 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19015 
  )
19016 
 
19017 
  def __init__(self, ex=None,):
19018 
    self.ex = ex
19019 
 
19020 
  def read(self, iprot):
19021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19023 
      return
19024 
    iprot.readStructBegin()
19025 
    while True:
19026 
      (fname, ftype, fid) = iprot.readFieldBegin()
19027 
      if ftype == TType.STOP:
19028 
        break
19029 
      if fid == 1:
19030 
        if ftype == TType.STRUCT:
19031 
          self.ex = TransactionServiceException()
19032 
          self.ex.read(iprot)
19033 
        else:
19034 
          iprot.skip(ftype)
19035 
      else:
19036 
        iprot.skip(ftype)
19037 
      iprot.readFieldEnd()
19038 
    iprot.readStructEnd()
19039 
 
19040 
  def write(self, oprot):
19041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19043 
      return
19044 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
19045 
    if self.ex is not None:
19046 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19047 
      self.ex.write(oprot)
19048 
      oprot.writeFieldEnd()
19049 
    oprot.writeFieldStop()
19050 
    oprot.writeStructEnd()
19051 
 
19052 
  def validate(self):
19053 
    return
19054 
 
19055 
 
19056 
  def __repr__(self):
19057 
    L = ['%s=%r' % (key, value)
19058 
      for key, value in self.__dict__.iteritems()]
19059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19060 
 
19061 
  def __eq__(self, other):
19062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19063 
 
19064 
  def __ne__(self, other):
19065 
    return not (self == other)
4369 rajveer 19066 
 
19067 
class markOrdersAsTimeout_args:
19068 
  """
19069 
  Attributes:
19070 
   - vendorId
19071 
  """
19072 
 
19073 
  thrift_spec = (
19074 
    None, # 0
19075 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19076 
  )
19077 
 
19078 
  def __init__(self, vendorId=None,):
19079 
    self.vendorId = vendorId
19080 
 
19081 
  def read(self, iprot):
19082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19084 
      return
19085 
    iprot.readStructBegin()
19086 
    while True:
19087 
      (fname, ftype, fid) = iprot.readFieldBegin()
19088 
      if ftype == TType.STOP:
19089 
        break
19090 
      if fid == 1:
19091 
        if ftype == TType.I64:
19092 
          self.vendorId = iprot.readI64();
19093 
        else:
19094 
          iprot.skip(ftype)
19095 
      else:
19096 
        iprot.skip(ftype)
19097 
      iprot.readFieldEnd()
19098 
    iprot.readStructEnd()
19099 
 
19100 
  def write(self, oprot):
19101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19103 
      return
19104 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
19105 
    if self.vendorId is not None:
19106 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19107 
      oprot.writeI64(self.vendorId)
19108 
      oprot.writeFieldEnd()
19109 
    oprot.writeFieldStop()
19110 
    oprot.writeStructEnd()
19111 
 
19112 
  def validate(self):
19113 
    return
19114 
 
19115 
 
19116 
  def __repr__(self):
19117 
    L = ['%s=%r' % (key, value)
19118 
      for key, value in self.__dict__.iteritems()]
19119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19120 
 
19121 
  def __eq__(self, other):
19122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19123 
 
19124 
  def __ne__(self, other):
19125 
    return not (self == other)
19126 
 
19127 
class markOrdersAsTimeout_result:
19128 
  """
19129 
  Attributes:
19130 
   - success
19131 
   - ex
19132 
  """
19133 
 
19134 
  thrift_spec = (
19135 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
19136 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19137 
  )
19138 
 
19139 
  def __init__(self, success=None, ex=None,):
19140 
    self.success = success
19141 
    self.ex = ex
19142 
 
19143 
  def read(self, iprot):
19144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19146 
      return
19147 
    iprot.readStructBegin()
19148 
    while True:
19149 
      (fname, ftype, fid) = iprot.readFieldBegin()
19150 
      if ftype == TType.STOP:
19151 
        break
19152 
      if fid == 0:
19153 
        if ftype == TType.MAP:
19154 
          self.success = {}
5031 varun.gupt 19155 
          (_ktype410, _vtype411, _size409 ) = iprot.readMapBegin()
19156 
          for _i413 in xrange(_size409):
19157 
            _key414 = iprot.readI32();
19158 
            _val415 = TimeoutSummary()
19159 
            _val415.read(iprot)
19160 
            self.success[_key414] = _val415
4369 rajveer 19161 
          iprot.readMapEnd()
19162 
        else:
19163 
          iprot.skip(ftype)
19164 
      elif fid == 1:
19165 
        if ftype == TType.STRUCT:
19166 
          self.ex = TransactionServiceException()
19167 
          self.ex.read(iprot)
19168 
        else:
19169 
          iprot.skip(ftype)
19170 
      else:
19171 
        iprot.skip(ftype)
19172 
      iprot.readFieldEnd()
19173 
    iprot.readStructEnd()
19174 
 
19175 
  def write(self, oprot):
19176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19178 
      return
19179 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
19180 
    if self.success is not None:
19181 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19182 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
5031 varun.gupt 19183 
      for kiter416,viter417 in self.success.items():
19184 
        oprot.writeI32(kiter416)
19185 
        viter417.write(oprot)
4369 rajveer 19186 
      oprot.writeMapEnd()
19187 
      oprot.writeFieldEnd()
19188 
    if self.ex is not None:
19189 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19190 
      self.ex.write(oprot)
19191 
      oprot.writeFieldEnd()
19192 
    oprot.writeFieldStop()
19193 
    oprot.writeStructEnd()
19194 
 
19195 
  def validate(self):
19196 
    return
19197 
 
19198 
 
19199 
  def __repr__(self):
19200 
    L = ['%s=%r' % (key, value)
19201 
      for key, value in self.__dict__.iteritems()]
19202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19203 
 
19204 
  def __eq__(self, other):
19205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19206 
 
19207 
  def __ne__(self, other):
19208 
    return not (self == other)
4386 anupam.sin 19209 
 
4662 rajveer 19210 
class markOrderAsLostInTransit_args:
19211 
  """
19212 
  Attributes:
19213 
   - orderId
19214 
  """
19215 
 
19216 
  thrift_spec = (
19217 
    None, # 0
19218 
    (1, TType.I64, 'orderId', None, None, ), # 1
19219 
  )
19220 
 
19221 
  def __init__(self, orderId=None,):
19222 
    self.orderId = orderId
19223 
 
19224 
  def read(self, iprot):
19225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19227 
      return
19228 
    iprot.readStructBegin()
19229 
    while True:
19230 
      (fname, ftype, fid) = iprot.readFieldBegin()
19231 
      if ftype == TType.STOP:
19232 
        break
19233 
      if fid == 1:
19234 
        if ftype == TType.I64:
19235 
          self.orderId = iprot.readI64();
19236 
        else:
19237 
          iprot.skip(ftype)
19238 
      else:
19239 
        iprot.skip(ftype)
19240 
      iprot.readFieldEnd()
19241 
    iprot.readStructEnd()
19242 
 
19243 
  def write(self, oprot):
19244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19246 
      return
19247 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
19248 
    if self.orderId is not None:
19249 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19250 
      oprot.writeI64(self.orderId)
19251 
      oprot.writeFieldEnd()
19252 
    oprot.writeFieldStop()
19253 
    oprot.writeStructEnd()
19254 
 
19255 
  def validate(self):
19256 
    return
19257 
 
19258 
 
19259 
  def __repr__(self):
19260 
    L = ['%s=%r' % (key, value)
19261 
      for key, value in self.__dict__.iteritems()]
19262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19263 
 
19264 
  def __eq__(self, other):
19265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19266 
 
19267 
  def __ne__(self, other):
19268 
    return not (self == other)
19269 
 
19270 
class markOrderAsLostInTransit_result:
19271 
  """
19272 
  Attributes:
19273 
   - success
19274 
   - ex
19275 
  """
19276 
 
19277 
  thrift_spec = (
19278 
    (0, TType.BOOL, 'success', None, None, ), # 0
19279 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19280 
  )
19281 
 
19282 
  def __init__(self, success=None, ex=None,):
19283 
    self.success = success
19284 
    self.ex = ex
19285 
 
19286 
  def read(self, iprot):
19287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19289 
      return
19290 
    iprot.readStructBegin()
19291 
    while True:
19292 
      (fname, ftype, fid) = iprot.readFieldBegin()
19293 
      if ftype == TType.STOP:
19294 
        break
19295 
      if fid == 0:
19296 
        if ftype == TType.BOOL:
19297 
          self.success = iprot.readBool();
19298 
        else:
19299 
          iprot.skip(ftype)
19300 
      elif fid == 1:
19301 
        if ftype == TType.STRUCT:
19302 
          self.ex = TransactionServiceException()
19303 
          self.ex.read(iprot)
19304 
        else:
19305 
          iprot.skip(ftype)
19306 
      else:
19307 
        iprot.skip(ftype)
19308 
      iprot.readFieldEnd()
19309 
    iprot.readStructEnd()
19310 
 
19311 
  def write(self, oprot):
19312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19314 
      return
19315 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
19316 
    if self.success is not None:
19317 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19318 
      oprot.writeBool(self.success)
19319 
      oprot.writeFieldEnd()
19320 
    if self.ex is not None:
19321 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19322 
      self.ex.write(oprot)
19323 
      oprot.writeFieldEnd()
19324 
    oprot.writeFieldStop()
19325 
    oprot.writeStructEnd()
19326 
 
19327 
  def validate(self):
19328 
    return
19329 
 
19330 
 
19331 
  def __repr__(self):
19332 
    L = ['%s=%r' % (key, value)
19333 
      for key, value in self.__dict__.iteritems()]
19334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19335 
 
19336 
  def __eq__(self, other):
19337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19338 
 
19339 
  def __ne__(self, other):
19340 
    return not (self == other)
19341 
 
4386 anupam.sin 19342 
class getOrderForAwb_args:
19343 
  """
19344 
  Attributes:
19345 
   - awb
19346 
  """
19347 
 
19348 
  thrift_spec = (
19349 
    None, # 0
19350 
    (1, TType.STRING, 'awb', None, None, ), # 1
19351 
  )
19352 
 
19353 
  def __init__(self, awb=None,):
19354 
    self.awb = awb
19355 
 
19356 
  def read(self, iprot):
19357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19359 
      return
19360 
    iprot.readStructBegin()
19361 
    while True:
19362 
      (fname, ftype, fid) = iprot.readFieldBegin()
19363 
      if ftype == TType.STOP:
19364 
        break
19365 
      if fid == 1:
19366 
        if ftype == TType.STRING:
19367 
          self.awb = iprot.readString();
19368 
        else:
19369 
          iprot.skip(ftype)
19370 
      else:
19371 
        iprot.skip(ftype)
19372 
      iprot.readFieldEnd()
19373 
    iprot.readStructEnd()
19374 
 
19375 
  def write(self, oprot):
19376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19378 
      return
19379 
    oprot.writeStructBegin('getOrderForAwb_args')
19380 
    if self.awb is not None:
19381 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
19382 
      oprot.writeString(self.awb)
19383 
      oprot.writeFieldEnd()
19384 
    oprot.writeFieldStop()
19385 
    oprot.writeStructEnd()
19386 
 
19387 
  def validate(self):
19388 
    return
19389 
 
19390 
 
19391 
  def __repr__(self):
19392 
    L = ['%s=%r' % (key, value)
19393 
      for key, value in self.__dict__.iteritems()]
19394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19395 
 
19396 
  def __eq__(self, other):
19397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19398 
 
19399 
  def __ne__(self, other):
19400 
    return not (self == other)
19401 
 
19402 
class getOrderForAwb_result:
19403 
  """
19404 
  Attributes:
19405 
   - success
19406 
   - ex
19407 
  """
19408 
 
19409 
  thrift_spec = (
19410 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19411 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19412 
  )
19413 
 
19414 
  def __init__(self, success=None, ex=None,):
19415 
    self.success = success
19416 
    self.ex = ex
19417 
 
19418 
  def read(self, iprot):
19419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19421 
      return
19422 
    iprot.readStructBegin()
19423 
    while True:
19424 
      (fname, ftype, fid) = iprot.readFieldBegin()
19425 
      if ftype == TType.STOP:
19426 
        break
19427 
      if fid == 0:
19428 
        if ftype == TType.STRUCT:
19429 
          self.success = Order()
19430 
          self.success.read(iprot)
19431 
        else:
19432 
          iprot.skip(ftype)
19433 
      elif fid == 1:
19434 
        if ftype == TType.STRUCT:
19435 
          self.ex = TransactionServiceException()
19436 
          self.ex.read(iprot)
19437 
        else:
19438 
          iprot.skip(ftype)
19439 
      else:
19440 
        iprot.skip(ftype)
19441 
      iprot.readFieldEnd()
19442 
    iprot.readStructEnd()
19443 
 
19444 
  def write(self, oprot):
19445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19447 
      return
19448 
    oprot.writeStructBegin('getOrderForAwb_result')
19449 
    if self.success is not None:
19450 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19451 
      self.success.write(oprot)
19452 
      oprot.writeFieldEnd()
19453 
    if self.ex is not None:
19454 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19455 
      self.ex.write(oprot)
19456 
      oprot.writeFieldEnd()
19457 
    oprot.writeFieldStop()
19458 
    oprot.writeStructEnd()
19459 
 
19460 
  def validate(self):
19461 
    return
19462 
 
19463 
 
19464 
  def __repr__(self):
19465 
    L = ['%s=%r' % (key, value)
19466 
      for key, value in self.__dict__.iteritems()]
19467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19468 
 
19469 
  def __eq__(self, other):
19470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19471 
 
19472 
  def __ne__(self, other):
19473 
    return not (self == other)
4506 phani.kuma 19474 
 
19475 
class getOrdersForProviderForStatus_args:
19476 
  """
19477 
  Attributes:
19478 
   - logistics_provider_id
4910 phani.kuma 19479 
   - order_status_list
4506 phani.kuma 19480 
  """
19481 
 
19482 
  thrift_spec = (
19483 
    None, # 0
19484 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 19485 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 19486 
  )
19487 
 
4910 phani.kuma 19488 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 19489 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 19490 
    self.order_status_list = order_status_list
4506 phani.kuma 19491 
 
19492 
  def read(self, iprot):
19493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19495 
      return
19496 
    iprot.readStructBegin()
19497 
    while True:
19498 
      (fname, ftype, fid) = iprot.readFieldBegin()
19499 
      if ftype == TType.STOP:
19500 
        break
19501 
      if fid == 1:
19502 
        if ftype == TType.I64:
19503 
          self.logistics_provider_id = iprot.readI64();
19504 
        else:
19505 
          iprot.skip(ftype)
19506 
      elif fid == 2:
4910 phani.kuma 19507 
        if ftype == TType.LIST:
19508 
          self.order_status_list = []
5031 varun.gupt 19509 
          (_etype421, _size418) = iprot.readListBegin()
19510 
          for _i422 in xrange(_size418):
19511 
            _elem423 = iprot.readI32();
19512 
            self.order_status_list.append(_elem423)
4910 phani.kuma 19513 
          iprot.readListEnd()
4506 phani.kuma 19514 
        else:
19515 
          iprot.skip(ftype)
19516 
      else:
19517 
        iprot.skip(ftype)
19518 
      iprot.readFieldEnd()
19519 
    iprot.readStructEnd()
19520 
 
19521 
  def write(self, oprot):
19522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19524 
      return
19525 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
19526 
    if self.logistics_provider_id is not None:
19527 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
19528 
      oprot.writeI64(self.logistics_provider_id)
19529 
      oprot.writeFieldEnd()
4910 phani.kuma 19530 
    if self.order_status_list is not None:
19531 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
19532 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
5031 varun.gupt 19533 
      for iter424 in self.order_status_list:
19534 
        oprot.writeI32(iter424)
4910 phani.kuma 19535 
      oprot.writeListEnd()
4506 phani.kuma 19536 
      oprot.writeFieldEnd()
19537 
    oprot.writeFieldStop()
19538 
    oprot.writeStructEnd()
19539 
 
19540 
  def validate(self):
19541 
    return
19542 
 
19543 
 
19544 
  def __repr__(self):
19545 
    L = ['%s=%r' % (key, value)
19546 
      for key, value in self.__dict__.iteritems()]
19547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19548 
 
19549 
  def __eq__(self, other):
19550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19551 
 
19552 
  def __ne__(self, other):
19553 
    return not (self == other)
19554 
 
19555 
class getOrdersForProviderForStatus_result:
19556 
  """
19557 
  Attributes:
19558 
   - success
19559 
   - ex
19560 
  """
19561 
 
19562 
  thrift_spec = (
19563 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19564 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19565 
  )
19566 
 
19567 
  def __init__(self, success=None, ex=None,):
19568 
    self.success = success
19569 
    self.ex = ex
19570 
 
19571 
  def read(self, iprot):
19572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19574 
      return
19575 
    iprot.readStructBegin()
19576 
    while True:
19577 
      (fname, ftype, fid) = iprot.readFieldBegin()
19578 
      if ftype == TType.STOP:
19579 
        break
19580 
      if fid == 0:
19581 
        if ftype == TType.LIST:
19582 
          self.success = []
5031 varun.gupt 19583 
          (_etype428, _size425) = iprot.readListBegin()
19584 
          for _i429 in xrange(_size425):
19585 
            _elem430 = Order()
19586 
            _elem430.read(iprot)
19587 
            self.success.append(_elem430)
4506 phani.kuma 19588 
          iprot.readListEnd()
19589 
        else:
19590 
          iprot.skip(ftype)
19591 
      elif fid == 1:
19592 
        if ftype == TType.STRUCT:
19593 
          self.ex = TransactionServiceException()
19594 
          self.ex.read(iprot)
19595 
        else:
19596 
          iprot.skip(ftype)
19597 
      else:
19598 
        iprot.skip(ftype)
19599 
      iprot.readFieldEnd()
19600 
    iprot.readStructEnd()
19601 
 
19602 
  def write(self, oprot):
19603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19605 
      return
19606 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
19607 
    if self.success is not None:
19608 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19609 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19610 
      for iter431 in self.success:
19611 
        iter431.write(oprot)
4506 phani.kuma 19612 
      oprot.writeListEnd()
19613 
      oprot.writeFieldEnd()
19614 
    if self.ex is not None:
19615 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19616 
      self.ex.write(oprot)
19617 
      oprot.writeFieldEnd()
19618 
    oprot.writeFieldStop()
19619 
    oprot.writeStructEnd()
19620 
 
19621 
  def validate(self):
19622 
    return
19623 
 
19624 
 
19625 
  def __repr__(self):
19626 
    L = ['%s=%r' % (key, value)
19627 
      for key, value in self.__dict__.iteritems()]
19628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19629 
 
19630 
  def __eq__(self, other):
19631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19632 
 
19633 
  def __ne__(self, other):
19634 
    return not (self == other)
4600 varun.gupt 19635 
 
19636 
class getBilledOrdersForVendor_args:
19637 
  """
19638 
  Attributes:
19639 
   - vendorId
19640 
   - billingDateFrom
19641 
   - billingDateTo
19642 
  """
19643 
 
19644 
  thrift_spec = (
19645 
    None, # 0
19646 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19647 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
19648 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
19649 
  )
19650 
 
19651 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
19652 
    self.vendorId = vendorId
19653 
    self.billingDateFrom = billingDateFrom
19654 
    self.billingDateTo = billingDateTo
19655 
 
19656 
  def read(self, iprot):
19657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19659 
      return
19660 
    iprot.readStructBegin()
19661 
    while True:
19662 
      (fname, ftype, fid) = iprot.readFieldBegin()
19663 
      if ftype == TType.STOP:
19664 
        break
19665 
      if fid == 1:
19666 
        if ftype == TType.I64:
19667 
          self.vendorId = iprot.readI64();
19668 
        else:
19669 
          iprot.skip(ftype)
19670 
      elif fid == 2:
19671 
        if ftype == TType.I64:
19672 
          self.billingDateFrom = iprot.readI64();
19673 
        else:
19674 
          iprot.skip(ftype)
19675 
      elif fid == 3:
19676 
        if ftype == TType.I64:
19677 
          self.billingDateTo = iprot.readI64();
19678 
        else:
19679 
          iprot.skip(ftype)
19680 
      else:
19681 
        iprot.skip(ftype)
19682 
      iprot.readFieldEnd()
19683 
    iprot.readStructEnd()
19684 
 
19685 
  def write(self, oprot):
19686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19688 
      return
19689 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
19690 
    if self.vendorId is not None:
19691 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19692 
      oprot.writeI64(self.vendorId)
19693 
      oprot.writeFieldEnd()
19694 
    if self.billingDateFrom is not None:
19695 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
19696 
      oprot.writeI64(self.billingDateFrom)
19697 
      oprot.writeFieldEnd()
19698 
    if self.billingDateTo is not None:
19699 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
19700 
      oprot.writeI64(self.billingDateTo)
19701 
      oprot.writeFieldEnd()
19702 
    oprot.writeFieldStop()
19703 
    oprot.writeStructEnd()
19704 
 
19705 
  def validate(self):
19706 
    return
19707 
 
19708 
 
19709 
  def __repr__(self):
19710 
    L = ['%s=%r' % (key, value)
19711 
      for key, value in self.__dict__.iteritems()]
19712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19713 
 
19714 
  def __eq__(self, other):
19715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19716 
 
19717 
  def __ne__(self, other):
19718 
    return not (self == other)
19719 
 
19720 
class getBilledOrdersForVendor_result:
19721 
  """
19722 
  Attributes:
19723 
   - success
19724 
   - ex
19725 
  """
19726 
 
19727 
  thrift_spec = (
19728 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19729 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19730 
  )
19731 
 
19732 
  def __init__(self, success=None, ex=None,):
19733 
    self.success = success
19734 
    self.ex = ex
19735 
 
19736 
  def read(self, iprot):
19737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19739 
      return
19740 
    iprot.readStructBegin()
19741 
    while True:
19742 
      (fname, ftype, fid) = iprot.readFieldBegin()
19743 
      if ftype == TType.STOP:
19744 
        break
19745 
      if fid == 0:
19746 
        if ftype == TType.LIST:
19747 
          self.success = []
5031 varun.gupt 19748 
          (_etype435, _size432) = iprot.readListBegin()
19749 
          for _i436 in xrange(_size432):
19750 
            _elem437 = Order()
19751 
            _elem437.read(iprot)
19752 
            self.success.append(_elem437)
4600 varun.gupt 19753 
          iprot.readListEnd()
19754 
        else:
19755 
          iprot.skip(ftype)
19756 
      elif fid == 1:
19757 
        if ftype == TType.STRUCT:
19758 
          self.ex = TransactionServiceException()
19759 
          self.ex.read(iprot)
19760 
        else:
19761 
          iprot.skip(ftype)
19762 
      else:
19763 
        iprot.skip(ftype)
19764 
      iprot.readFieldEnd()
19765 
    iprot.readStructEnd()
19766 
 
19767 
  def write(self, oprot):
19768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19770 
      return
19771 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
19772 
    if self.success is not None:
19773 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19774 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19775 
      for iter438 in self.success:
19776 
        iter438.write(oprot)
4600 varun.gupt 19777 
      oprot.writeListEnd()
19778 
      oprot.writeFieldEnd()
19779 
    if self.ex is not None:
19780 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19781 
      self.ex.write(oprot)
19782 
      oprot.writeFieldEnd()
19783 
    oprot.writeFieldStop()
19784 
    oprot.writeStructEnd()
19785 
 
19786 
  def validate(self):
19787 
    return
19788 
 
19789 
 
19790 
  def __repr__(self):
19791 
    L = ['%s=%r' % (key, value)
19792 
      for key, value in self.__dict__.iteritems()]
19793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19794 
 
19795 
  def __eq__(self, other):
19796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19797 
 
19798 
  def __ne__(self, other):
19799 
    return not (self == other)
19800 
 
4607 rajveer 19801 
class getSlippedSippingDateOrders_args:
19802 
 
19803 
  thrift_spec = (
19804 
  )
19805 
 
19806 
  def read(self, iprot):
19807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19809 
      return
19810 
    iprot.readStructBegin()
19811 
    while True:
19812 
      (fname, ftype, fid) = iprot.readFieldBegin()
19813 
      if ftype == TType.STOP:
19814 
        break
19815 
      else:
19816 
        iprot.skip(ftype)
19817 
      iprot.readFieldEnd()
19818 
    iprot.readStructEnd()
19819 
 
19820 
  def write(self, oprot):
19821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19823 
      return
19824 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
19825 
    oprot.writeFieldStop()
19826 
    oprot.writeStructEnd()
19827 
 
19828 
  def validate(self):
19829 
    return
19830 
 
19831 
 
19832 
  def __repr__(self):
19833 
    L = ['%s=%r' % (key, value)
19834 
      for key, value in self.__dict__.iteritems()]
19835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19836 
 
19837 
  def __eq__(self, other):
19838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19839 
 
19840 
  def __ne__(self, other):
19841 
    return not (self == other)
19842 
 
19843 
class getSlippedSippingDateOrders_result:
19844 
  """
19845 
  Attributes:
19846 
   - success
19847 
   - ex
19848 
  """
19849 
 
19850 
  thrift_spec = (
19851 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19852 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19853 
  )
19854 
 
19855 
  def __init__(self, success=None, ex=None,):
19856 
    self.success = success
19857 
    self.ex = ex
19858 
 
19859 
  def read(self, iprot):
19860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19862 
      return
19863 
    iprot.readStructBegin()
19864 
    while True:
19865 
      (fname, ftype, fid) = iprot.readFieldBegin()
19866 
      if ftype == TType.STOP:
19867 
        break
19868 
      if fid == 0:
19869 
        if ftype == TType.LIST:
19870 
          self.success = []
5031 varun.gupt 19871 
          (_etype442, _size439) = iprot.readListBegin()
19872 
          for _i443 in xrange(_size439):
19873 
            _elem444 = Order()
19874 
            _elem444.read(iprot)
19875 
            self.success.append(_elem444)
4607 rajveer 19876 
          iprot.readListEnd()
19877 
        else:
19878 
          iprot.skip(ftype)
19879 
      elif fid == 1:
19880 
        if ftype == TType.STRUCT:
19881 
          self.ex = TransactionServiceException()
19882 
          self.ex.read(iprot)
19883 
        else:
19884 
          iprot.skip(ftype)
19885 
      else:
19886 
        iprot.skip(ftype)
19887 
      iprot.readFieldEnd()
19888 
    iprot.readStructEnd()
19889 
 
19890 
  def write(self, oprot):
19891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19893 
      return
19894 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
19895 
    if self.success is not None:
19896 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19897 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19898 
      for iter445 in self.success:
19899 
        iter445.write(oprot)
4607 rajveer 19900 
      oprot.writeListEnd()
19901 
      oprot.writeFieldEnd()
19902 
    if self.ex is not None:
19903 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19904 
      self.ex.write(oprot)
19905 
      oprot.writeFieldEnd()
19906 
    oprot.writeFieldStop()
19907 
    oprot.writeStructEnd()
19908 
 
19909 
  def validate(self):
19910 
    return
19911 
 
19912 
 
19913 
  def __repr__(self):
19914 
    L = ['%s=%r' % (key, value)
19915 
      for key, value in self.__dict__.iteritems()]
19916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19917 
 
19918 
  def __eq__(self, other):
19919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19920 
 
19921 
  def __ne__(self, other):
19922 
    return not (self == other)
19923 
 
4709 rajveer 19924 
class getCancelledOrders_args:
19925 
  """
19926 
  Attributes:
19927 
   - cancelDateFrom
19928 
   - cancelDateTo
19929 
  """
19930 
 
19931 
  thrift_spec = (
19932 
    None, # 0
19933 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
19934 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
19935 
  )
19936 
 
19937 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
19938 
    self.cancelDateFrom = cancelDateFrom
19939 
    self.cancelDateTo = cancelDateTo
19940 
 
19941 
  def read(self, iprot):
19942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19944 
      return
19945 
    iprot.readStructBegin()
19946 
    while True:
19947 
      (fname, ftype, fid) = iprot.readFieldBegin()
19948 
      if ftype == TType.STOP:
19949 
        break
19950 
      if fid == 1:
19951 
        if ftype == TType.I64:
19952 
          self.cancelDateFrom = iprot.readI64();
19953 
        else:
19954 
          iprot.skip(ftype)
19955 
      elif fid == 2:
19956 
        if ftype == TType.I64:
19957 
          self.cancelDateTo = iprot.readI64();
19958 
        else:
19959 
          iprot.skip(ftype)
19960 
      else:
19961 
        iprot.skip(ftype)
19962 
      iprot.readFieldEnd()
19963 
    iprot.readStructEnd()
19964 
 
19965 
  def write(self, oprot):
19966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19968 
      return
19969 
    oprot.writeStructBegin('getCancelledOrders_args')
19970 
    if self.cancelDateFrom is not None:
19971 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
19972 
      oprot.writeI64(self.cancelDateFrom)
19973 
      oprot.writeFieldEnd()
19974 
    if self.cancelDateTo is not None:
19975 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
19976 
      oprot.writeI64(self.cancelDateTo)
19977 
      oprot.writeFieldEnd()
19978 
    oprot.writeFieldStop()
19979 
    oprot.writeStructEnd()
19980 
 
19981 
  def validate(self):
19982 
    return
19983 
 
19984 
 
19985 
  def __repr__(self):
19986 
    L = ['%s=%r' % (key, value)
19987 
      for key, value in self.__dict__.iteritems()]
19988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19989 
 
19990 
  def __eq__(self, other):
19991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19992 
 
19993 
  def __ne__(self, other):
19994 
    return not (self == other)
19995 
 
19996 
class getCancelledOrders_result:
19997 
  """
19998 
  Attributes:
19999 
   - success
20000 
   - ex
20001 
  """
20002 
 
20003 
  thrift_spec = (
20004 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20005 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20006 
  )
20007 
 
20008 
  def __init__(self, success=None, ex=None,):
20009 
    self.success = success
20010 
    self.ex = ex
20011 
 
20012 
  def read(self, iprot):
20013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20015 
      return
20016 
    iprot.readStructBegin()
20017 
    while True:
20018 
      (fname, ftype, fid) = iprot.readFieldBegin()
20019 
      if ftype == TType.STOP:
20020 
        break
20021 
      if fid == 0:
20022 
        if ftype == TType.LIST:
20023 
          self.success = []
5031 varun.gupt 20024 
          (_etype449, _size446) = iprot.readListBegin()
20025 
          for _i450 in xrange(_size446):
20026 
            _elem451 = Order()
20027 
            _elem451.read(iprot)
20028 
            self.success.append(_elem451)
4709 rajveer 20029 
          iprot.readListEnd()
20030 
        else:
20031 
          iprot.skip(ftype)
20032 
      elif fid == 1:
20033 
        if ftype == TType.STRUCT:
20034 
          self.ex = TransactionServiceException()
20035 
          self.ex.read(iprot)
20036 
        else:
20037 
          iprot.skip(ftype)
20038 
      else:
20039 
        iprot.skip(ftype)
20040 
      iprot.readFieldEnd()
20041 
    iprot.readStructEnd()
20042 
 
20043 
  def write(self, oprot):
20044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20046 
      return
20047 
    oprot.writeStructBegin('getCancelledOrders_result')
20048 
    if self.success is not None:
20049 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20050 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 20051 
      for iter452 in self.success:
20052 
        iter452.write(oprot)
4709 rajveer 20053 
      oprot.writeListEnd()
20054 
      oprot.writeFieldEnd()
20055 
    if self.ex is not None:
20056 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20057 
      self.ex.write(oprot)
20058 
      oprot.writeFieldEnd()
20059 
    oprot.writeFieldStop()
20060 
    oprot.writeStructEnd()
20061 
 
20062 
  def validate(self):
20063 
    return
20064 
 
20065 
 
20066 
  def __repr__(self):
20067 
    L = ['%s=%r' % (key, value)
20068 
      for key, value in self.__dict__.iteritems()]
20069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20070 
 
20071 
  def __eq__(self, other):
20072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20073 
 
20074 
  def __ne__(self, other):
20075 
    return not (self == other)
20076 
 
4600 varun.gupt 20077 
class saveBluedartSettlements_args:
20078 
  """
20079 
  Attributes:
20080 
   - mapAWBAndAmount
20081 
  """
20082 
 
20083 
  thrift_spec = (
20084 
    None, # 0
20085 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
20086 
  )
20087 
 
20088 
  def __init__(self, mapAWBAndAmount=None,):
20089 
    self.mapAWBAndAmount = mapAWBAndAmount
20090 
 
20091 
  def read(self, iprot):
20092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20094 
      return
20095 
    iprot.readStructBegin()
20096 
    while True:
20097 
      (fname, ftype, fid) = iprot.readFieldBegin()
20098 
      if ftype == TType.STOP:
20099 
        break
20100 
      if fid == 1:
20101 
        if ftype == TType.MAP:
20102 
          self.mapAWBAndAmount = {}
5031 varun.gupt 20103 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
20104 
          for _i457 in xrange(_size453):
20105 
            _key458 = iprot.readI64();
20106 
            _val459 = iprot.readDouble();
20107 
            self.mapAWBAndAmount[_key458] = _val459
4600 varun.gupt 20108 
          iprot.readMapEnd()
20109 
        else:
20110 
          iprot.skip(ftype)
20111 
      else:
20112 
        iprot.skip(ftype)
20113 
      iprot.readFieldEnd()
20114 
    iprot.readStructEnd()
20115 
 
20116 
  def write(self, oprot):
20117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20119 
      return
20120 
    oprot.writeStructBegin('saveBluedartSettlements_args')
20121 
    if self.mapAWBAndAmount is not None:
20122 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
20123 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
5031 varun.gupt 20124 
      for kiter460,viter461 in self.mapAWBAndAmount.items():
20125 
        oprot.writeI64(kiter460)
20126 
        oprot.writeDouble(viter461)
4600 varun.gupt 20127 
      oprot.writeMapEnd()
20128 
      oprot.writeFieldEnd()
20129 
    oprot.writeFieldStop()
20130 
    oprot.writeStructEnd()
20131 
 
20132 
  def validate(self):
20133 
    return
20134 
 
20135 
 
20136 
  def __repr__(self):
20137 
    L = ['%s=%r' % (key, value)
20138 
      for key, value in self.__dict__.iteritems()]
20139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20140 
 
20141 
  def __eq__(self, other):
20142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20143 
 
20144 
  def __ne__(self, other):
20145 
    return not (self == other)
20146 
 
20147 
class saveBluedartSettlements_result:
20148 
  """
20149 
  Attributes:
20150 
   - ex
20151 
  """
20152 
 
20153 
  thrift_spec = (
20154 
    None, # 0
20155 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20156 
  )
20157 
 
20158 
  def __init__(self, ex=None,):
20159 
    self.ex = ex
20160 
 
20161 
  def read(self, iprot):
20162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20164 
      return
20165 
    iprot.readStructBegin()
20166 
    while True:
20167 
      (fname, ftype, fid) = iprot.readFieldBegin()
20168 
      if ftype == TType.STOP:
20169 
        break
20170 
      if fid == 1:
20171 
        if ftype == TType.STRUCT:
20172 
          self.ex = TransactionServiceException()
20173 
          self.ex.read(iprot)
20174 
        else:
20175 
          iprot.skip(ftype)
20176 
      else:
20177 
        iprot.skip(ftype)
20178 
      iprot.readFieldEnd()
20179 
    iprot.readStructEnd()
20180 
 
20181 
  def write(self, oprot):
20182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20184 
      return
20185 
    oprot.writeStructBegin('saveBluedartSettlements_result')
20186 
    if self.ex is not None:
20187 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20188 
      self.ex.write(oprot)
20189 
      oprot.writeFieldEnd()
20190 
    oprot.writeFieldStop()
20191 
    oprot.writeStructEnd()
20192 
 
20193 
  def validate(self):
20194 
    return
20195 
 
20196 
 
20197 
  def __repr__(self):
20198 
    L = ['%s=%r' % (key, value)
20199 
      for key, value in self.__dict__.iteritems()]
20200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20201 
 
20202 
  def __eq__(self, other):
20203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20204 
 
20205 
  def __ne__(self, other):
20206 
    return not (self == other)
20207 
 
20208 
class savePaymentSettlements_args:
20209 
  """
20210 
  Attributes:
20211 
   - settlementDate
20212 
   - paymentGatewayId
4905 varun.gupt 20213 
   - referenceId
4600 varun.gupt 20214 
   - serviceTax
20215 
   - otherCharges
20216 
   - netCollection
20217 
  """
20218 
 
20219 
  thrift_spec = (
20220 
    None, # 0
20221 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
20222 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 20223 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 20224 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
20225 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
20226 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
20227 
  )
20228 
 
4905 varun.gupt 20229 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 20230 
    self.settlementDate = settlementDate
20231 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 20232 
    self.referenceId = referenceId
4600 varun.gupt 20233 
    self.serviceTax = serviceTax
20234 
    self.otherCharges = otherCharges
20235 
    self.netCollection = netCollection
20236 
 
20237 
  def read(self, iprot):
20238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20240 
      return
20241 
    iprot.readStructBegin()
20242 
    while True:
20243 
      (fname, ftype, fid) = iprot.readFieldBegin()
20244 
      if ftype == TType.STOP:
20245 
        break
20246 
      if fid == 1:
20247 
        if ftype == TType.I64:
20248 
          self.settlementDate = iprot.readI64();
20249 
        else:
20250 
          iprot.skip(ftype)
20251 
      elif fid == 2:
20252 
        if ftype == TType.I64:
20253 
          self.paymentGatewayId = iprot.readI64();
20254 
        else:
20255 
          iprot.skip(ftype)
20256 
      elif fid == 3:
20257 
        if ftype == TType.I64:
4905 varun.gupt 20258 
          self.referenceId = iprot.readI64();
4600 varun.gupt 20259 
        else:
20260 
          iprot.skip(ftype)
20261 
      elif fid == 4:
20262 
        if ftype == TType.DOUBLE:
20263 
          self.serviceTax = iprot.readDouble();
20264 
        else:
20265 
          iprot.skip(ftype)
20266 
      elif fid == 5:
20267 
        if ftype == TType.DOUBLE:
20268 
          self.otherCharges = iprot.readDouble();
20269 
        else:
20270 
          iprot.skip(ftype)
20271 
      elif fid == 6:
20272 
        if ftype == TType.DOUBLE:
20273 
          self.netCollection = iprot.readDouble();
20274 
        else:
20275 
          iprot.skip(ftype)
20276 
      else:
20277 
        iprot.skip(ftype)
20278 
      iprot.readFieldEnd()
20279 
    iprot.readStructEnd()
20280 
 
20281 
  def write(self, oprot):
20282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20284 
      return
20285 
    oprot.writeStructBegin('savePaymentSettlements_args')
20286 
    if self.settlementDate is not None:
20287 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
20288 
      oprot.writeI64(self.settlementDate)
20289 
      oprot.writeFieldEnd()
20290 
    if self.paymentGatewayId is not None:
20291 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
20292 
      oprot.writeI64(self.paymentGatewayId)
20293 
      oprot.writeFieldEnd()
4905 varun.gupt 20294 
    if self.referenceId is not None:
20295 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
20296 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 20297 
      oprot.writeFieldEnd()
20298 
    if self.serviceTax is not None:
20299 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
20300 
      oprot.writeDouble(self.serviceTax)
20301 
      oprot.writeFieldEnd()
20302 
    if self.otherCharges is not None:
20303 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
20304 
      oprot.writeDouble(self.otherCharges)
20305 
      oprot.writeFieldEnd()
20306 
    if self.netCollection is not None:
20307 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
20308 
      oprot.writeDouble(self.netCollection)
20309 
      oprot.writeFieldEnd()
20310 
    oprot.writeFieldStop()
20311 
    oprot.writeStructEnd()
20312 
 
20313 
  def validate(self):
20314 
    return
20315 
 
20316 
 
20317 
  def __repr__(self):
20318 
    L = ['%s=%r' % (key, value)
20319 
      for key, value in self.__dict__.iteritems()]
20320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20321 
 
20322 
  def __eq__(self, other):
20323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20324 
 
20325 
  def __ne__(self, other):
20326 
    return not (self == other)
20327 
 
20328 
class savePaymentSettlements_result:
20329 
  """
20330 
  Attributes:
20331 
   - ex
20332 
  """
20333 
 
20334 
  thrift_spec = (
20335 
    None, # 0
20336 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20337 
  )
20338 
 
20339 
  def __init__(self, ex=None,):
20340 
    self.ex = ex
20341 
 
20342 
  def read(self, iprot):
20343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20345 
      return
20346 
    iprot.readStructBegin()
20347 
    while True:
20348 
      (fname, ftype, fid) = iprot.readFieldBegin()
20349 
      if ftype == TType.STOP:
20350 
        break
20351 
      if fid == 1:
20352 
        if ftype == TType.STRUCT:
20353 
          self.ex = TransactionServiceException()
20354 
          self.ex.read(iprot)
20355 
        else:
20356 
          iprot.skip(ftype)
20357 
      else:
20358 
        iprot.skip(ftype)
20359 
      iprot.readFieldEnd()
20360 
    iprot.readStructEnd()
20361 
 
20362 
  def write(self, oprot):
20363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20365 
      return
20366 
    oprot.writeStructBegin('savePaymentSettlements_result')
20367 
    if self.ex is not None:
20368 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20369 
      self.ex.write(oprot)
20370 
      oprot.writeFieldEnd()
20371 
    oprot.writeFieldStop()
20372 
    oprot.writeStructEnd()
20373 
 
20374 
  def validate(self):
20375 
    return
20376 
 
20377 
 
20378 
  def __repr__(self):
20379 
    L = ['%s=%r' % (key, value)
20380 
      for key, value in self.__dict__.iteritems()]
20381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20382 
 
20383 
  def __eq__(self, other):
20384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20385 
 
20386 
  def __ne__(self, other):
20387 
    return not (self == other)
20388 
 
20389 
class saveEBSSettlementSummary_args:
20390 
  """
20391 
  Attributes:
20392 
   - settlementId
20393 
   - settlementDate
20394 
   - transactionDateFrom
20395 
   - transactionDateTo
20396 
   - amount
20397 
  """
20398 
 
20399 
  thrift_spec = (
20400 
    None, # 0
20401 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20402 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
20403 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
20404 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
20405 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
20406 
  )
20407 
 
20408 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
20409 
    self.settlementId = settlementId
20410 
    self.settlementDate = settlementDate
20411 
    self.transactionDateFrom = transactionDateFrom
20412 
    self.transactionDateTo = transactionDateTo
20413 
    self.amount = amount
20414 
 
20415 
  def read(self, iprot):
20416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20418 
      return
20419 
    iprot.readStructBegin()
20420 
    while True:
20421 
      (fname, ftype, fid) = iprot.readFieldBegin()
20422 
      if ftype == TType.STOP:
20423 
        break
20424 
      if fid == 1:
20425 
        if ftype == TType.I64:
20426 
          self.settlementId = iprot.readI64();
20427 
        else:
20428 
          iprot.skip(ftype)
20429 
      elif fid == 2:
20430 
        if ftype == TType.I64:
20431 
          self.settlementDate = iprot.readI64();
20432 
        else:
20433 
          iprot.skip(ftype)
20434 
      elif fid == 3:
20435 
        if ftype == TType.I64:
20436 
          self.transactionDateFrom = iprot.readI64();
20437 
        else:
20438 
          iprot.skip(ftype)
20439 
      elif fid == 4:
20440 
        if ftype == TType.I64:
20441 
          self.transactionDateTo = iprot.readI64();
20442 
        else:
20443 
          iprot.skip(ftype)
20444 
      elif fid == 5:
20445 
        if ftype == TType.DOUBLE:
20446 
          self.amount = iprot.readDouble();
20447 
        else:
20448 
          iprot.skip(ftype)
20449 
      else:
20450 
        iprot.skip(ftype)
20451 
      iprot.readFieldEnd()
20452 
    iprot.readStructEnd()
20453 
 
20454 
  def write(self, oprot):
20455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20457 
      return
20458 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
20459 
    if self.settlementId is not None:
20460 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20461 
      oprot.writeI64(self.settlementId)
20462 
      oprot.writeFieldEnd()
20463 
    if self.settlementDate is not None:
20464 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
20465 
      oprot.writeI64(self.settlementDate)
20466 
      oprot.writeFieldEnd()
20467 
    if self.transactionDateFrom is not None:
20468 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
20469 
      oprot.writeI64(self.transactionDateFrom)
20470 
      oprot.writeFieldEnd()
20471 
    if self.transactionDateTo is not None:
20472 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
20473 
      oprot.writeI64(self.transactionDateTo)
20474 
      oprot.writeFieldEnd()
20475 
    if self.amount is not None:
20476 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
20477 
      oprot.writeDouble(self.amount)
20478 
      oprot.writeFieldEnd()
20479 
    oprot.writeFieldStop()
20480 
    oprot.writeStructEnd()
20481 
 
20482 
  def validate(self):
20483 
    return
20484 
 
20485 
 
20486 
  def __repr__(self):
20487 
    L = ['%s=%r' % (key, value)
20488 
      for key, value in self.__dict__.iteritems()]
20489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20490 
 
20491 
  def __eq__(self, other):
20492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20493 
 
20494 
  def __ne__(self, other):
20495 
    return not (self == other)
20496 
 
20497 
class saveEBSSettlementSummary_result:
20498 
  """
20499 
  Attributes:
20500 
   - ex
20501 
  """
20502 
 
20503 
  thrift_spec = (
20504 
    None, # 0
20505 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20506 
  )
20507 
 
20508 
  def __init__(self, ex=None,):
20509 
    self.ex = ex
20510 
 
20511 
  def read(self, iprot):
20512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20514 
      return
20515 
    iprot.readStructBegin()
20516 
    while True:
20517 
      (fname, ftype, fid) = iprot.readFieldBegin()
20518 
      if ftype == TType.STOP:
20519 
        break
20520 
      if fid == 1:
20521 
        if ftype == TType.STRUCT:
20522 
          self.ex = TransactionServiceException()
20523 
          self.ex.read(iprot)
20524 
        else:
20525 
          iprot.skip(ftype)
20526 
      else:
20527 
        iprot.skip(ftype)
20528 
      iprot.readFieldEnd()
20529 
    iprot.readStructEnd()
20530 
 
20531 
  def write(self, oprot):
20532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20534 
      return
20535 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
20536 
    if self.ex is not None:
20537 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20538 
      self.ex.write(oprot)
20539 
      oprot.writeFieldEnd()
20540 
    oprot.writeFieldStop()
20541 
    oprot.writeStructEnd()
20542 
 
20543 
  def validate(self):
20544 
    return
20545 
 
20546 
 
20547 
  def __repr__(self):
20548 
    L = ['%s=%r' % (key, value)
20549 
      for key, value in self.__dict__.iteritems()]
20550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20551 
 
20552 
  def __eq__(self, other):
20553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20554 
 
20555 
  def __ne__(self, other):
20556 
    return not (self == other)
20557 
 
20558 
class getSettlementForPaymentId_args:
20559 
  """
20560 
  Attributes:
20561 
   - paymentId
20562 
  """
20563 
 
20564 
  thrift_spec = (
20565 
    None, # 0
20566 
    (1, TType.I64, 'paymentId', None, None, ), # 1
20567 
  )
20568 
 
20569 
  def __init__(self, paymentId=None,):
20570 
    self.paymentId = paymentId
20571 
 
20572 
  def read(self, iprot):
20573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20575 
      return
20576 
    iprot.readStructBegin()
20577 
    while True:
20578 
      (fname, ftype, fid) = iprot.readFieldBegin()
20579 
      if ftype == TType.STOP:
20580 
        break
20581 
      if fid == 1:
20582 
        if ftype == TType.I64:
20583 
          self.paymentId = iprot.readI64();
20584 
        else:
20585 
          iprot.skip(ftype)
20586 
      else:
20587 
        iprot.skip(ftype)
20588 
      iprot.readFieldEnd()
20589 
    iprot.readStructEnd()
20590 
 
20591 
  def write(self, oprot):
20592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20594 
      return
20595 
    oprot.writeStructBegin('getSettlementForPaymentId_args')
20596 
    if self.paymentId is not None:
20597 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
20598 
      oprot.writeI64(self.paymentId)
20599 
      oprot.writeFieldEnd()
20600 
    oprot.writeFieldStop()
20601 
    oprot.writeStructEnd()
20602 
 
20603 
  def validate(self):
20604 
    return
20605 
 
20606 
 
20607 
  def __repr__(self):
20608 
    L = ['%s=%r' % (key, value)
20609 
      for key, value in self.__dict__.iteritems()]
20610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20611 
 
20612 
  def __eq__(self, other):
20613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20614 
 
20615 
  def __ne__(self, other):
20616 
    return not (self == other)
20617 
 
20618 
class getSettlementForPaymentId_result:
20619 
  """
20620 
  Attributes:
20621 
   - success
20622 
   - ex
20623 
  """
20624 
 
20625 
  thrift_spec = (
20626 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
20627 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20628 
  )
20629 
 
20630 
  def __init__(self, success=None, ex=None,):
20631 
    self.success = success
20632 
    self.ex = ex
20633 
 
20634 
  def read(self, iprot):
20635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20637 
      return
20638 
    iprot.readStructBegin()
20639 
    while True:
20640 
      (fname, ftype, fid) = iprot.readFieldBegin()
20641 
      if ftype == TType.STOP:
20642 
        break
20643 
      if fid == 0:
20644 
        if ftype == TType.STRUCT:
20645 
          self.success = PaymentSettlement()
20646 
          self.success.read(iprot)
20647 
        else:
20648 
          iprot.skip(ftype)
20649 
      elif fid == 1:
20650 
        if ftype == TType.STRUCT:
20651 
          self.ex = TransactionServiceException()
20652 
          self.ex.read(iprot)
20653 
        else:
20654 
          iprot.skip(ftype)
20655 
      else:
20656 
        iprot.skip(ftype)
20657 
      iprot.readFieldEnd()
20658 
    iprot.readStructEnd()
20659 
 
20660 
  def write(self, oprot):
20661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20663 
      return
20664 
    oprot.writeStructBegin('getSettlementForPaymentId_result')
20665 
    if self.success is not None:
20666 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20667 
      self.success.write(oprot)
20668 
      oprot.writeFieldEnd()
20669 
    if self.ex is not None:
20670 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20671 
      self.ex.write(oprot)
20672 
      oprot.writeFieldEnd()
20673 
    oprot.writeFieldStop()
20674 
    oprot.writeStructEnd()
20675 
 
20676 
  def validate(self):
20677 
    return
20678 
 
20679 
 
20680 
  def __repr__(self):
20681 
    L = ['%s=%r' % (key, value)
20682 
      for key, value in self.__dict__.iteritems()]
20683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20684 
 
20685 
  def __eq__(self, other):
20686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20687 
 
20688 
  def __ne__(self, other):
20689 
    return not (self == other)
20690 
 
20691 
class getEBSSettlementSummaries_args:
20692 
 
20693 
  thrift_spec = (
20694 
  )
20695 
 
20696 
  def read(self, iprot):
20697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20699 
      return
20700 
    iprot.readStructBegin()
20701 
    while True:
20702 
      (fname, ftype, fid) = iprot.readFieldBegin()
20703 
      if ftype == TType.STOP:
20704 
        break
20705 
      else:
20706 
        iprot.skip(ftype)
20707 
      iprot.readFieldEnd()
20708 
    iprot.readStructEnd()
20709 
 
20710 
  def write(self, oprot):
20711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20713 
      return
20714 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
20715 
    oprot.writeFieldStop()
20716 
    oprot.writeStructEnd()
20717 
 
20718 
  def validate(self):
20719 
    return
20720 
 
20721 
 
20722 
  def __repr__(self):
20723 
    L = ['%s=%r' % (key, value)
20724 
      for key, value in self.__dict__.iteritems()]
20725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20726 
 
20727 
  def __eq__(self, other):
20728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20729 
 
20730 
  def __ne__(self, other):
20731 
    return not (self == other)
20732 
 
20733 
class getEBSSettlementSummaries_result:
20734 
  """
20735 
  Attributes:
20736 
   - success
20737 
   - ex
20738 
  """
20739 
 
20740 
  thrift_spec = (
20741 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
20742 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20743 
  )
20744 
 
20745 
  def __init__(self, success=None, ex=None,):
20746 
    self.success = success
20747 
    self.ex = ex
20748 
 
20749 
  def read(self, iprot):
20750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20752 
      return
20753 
    iprot.readStructBegin()
20754 
    while True:
20755 
      (fname, ftype, fid) = iprot.readFieldBegin()
20756 
      if ftype == TType.STOP:
20757 
        break
20758 
      if fid == 0:
20759 
        if ftype == TType.MAP:
20760 
          self.success = {}
5031 varun.gupt 20761 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20762 
          for _i466 in xrange(_size462):
20763 
            _key467 = iprot.readI64();
20764 
            _val468 = iprot.readString();
20765 
            self.success[_key467] = _val468
4600 varun.gupt 20766 
          iprot.readMapEnd()
20767 
        else:
20768 
          iprot.skip(ftype)
20769 
      elif fid == 1:
20770 
        if ftype == TType.STRUCT:
20771 
          self.ex = TransactionServiceException()
20772 
          self.ex.read(iprot)
20773 
        else:
20774 
          iprot.skip(ftype)
20775 
      else:
20776 
        iprot.skip(ftype)
20777 
      iprot.readFieldEnd()
20778 
    iprot.readStructEnd()
20779 
 
20780 
  def write(self, oprot):
20781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20783 
      return
20784 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
20785 
    if self.success is not None:
20786 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20787 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
5031 varun.gupt 20788 
      for kiter469,viter470 in self.success.items():
20789 
        oprot.writeI64(kiter469)
20790 
        oprot.writeString(viter470)
4600 varun.gupt 20791 
      oprot.writeMapEnd()
20792 
      oprot.writeFieldEnd()
20793 
    if self.ex is not None:
20794 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20795 
      self.ex.write(oprot)
20796 
      oprot.writeFieldEnd()
20797 
    oprot.writeFieldStop()
20798 
    oprot.writeStructEnd()
20799 
 
20800 
  def validate(self):
20801 
    return
20802 
 
20803 
 
20804 
  def __repr__(self):
20805 
    L = ['%s=%r' % (key, value)
20806 
      for key, value in self.__dict__.iteritems()]
20807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20808 
 
20809 
  def __eq__(self, other):
20810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20811 
 
20812 
  def __ne__(self, other):
20813 
    return not (self == other)
20814 
 
20815 
class markEBSSettlementUploaded_args:
20816 
  """
20817 
  Attributes:
20818 
   - settlementId
20819 
  """
20820 
 
20821 
  thrift_spec = (
20822 
    None, # 0
20823 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20824 
  )
20825 
 
20826 
  def __init__(self, settlementId=None,):
20827 
    self.settlementId = settlementId
20828 
 
20829 
  def read(self, iprot):
20830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20832 
      return
20833 
    iprot.readStructBegin()
20834 
    while True:
20835 
      (fname, ftype, fid) = iprot.readFieldBegin()
20836 
      if ftype == TType.STOP:
20837 
        break
20838 
      if fid == 1:
20839 
        if ftype == TType.I64:
20840 
          self.settlementId = iprot.readI64();
20841 
        else:
20842 
          iprot.skip(ftype)
20843 
      else:
20844 
        iprot.skip(ftype)
20845 
      iprot.readFieldEnd()
20846 
    iprot.readStructEnd()
20847 
 
20848 
  def write(self, oprot):
20849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20851 
      return
20852 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
20853 
    if self.settlementId is not None:
20854 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20855 
      oprot.writeI64(self.settlementId)
20856 
      oprot.writeFieldEnd()
20857 
    oprot.writeFieldStop()
20858 
    oprot.writeStructEnd()
20859 
 
20860 
  def validate(self):
20861 
    return
20862 
 
20863 
 
20864 
  def __repr__(self):
20865 
    L = ['%s=%r' % (key, value)
20866 
      for key, value in self.__dict__.iteritems()]
20867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20868 
 
20869 
  def __eq__(self, other):
20870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20871 
 
20872 
  def __ne__(self, other):
20873 
    return not (self == other)
20874 
 
20875 
class markEBSSettlementUploaded_result:
20876 
  """
20877 
  Attributes:
20878 
   - ex
20879 
  """
20880 
 
20881 
  thrift_spec = (
20882 
    None, # 0
20883 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20884 
  )
20885 
 
20886 
  def __init__(self, ex=None,):
20887 
    self.ex = ex
20888 
 
20889 
  def read(self, iprot):
20890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20892 
      return
20893 
    iprot.readStructBegin()
20894 
    while True:
20895 
      (fname, ftype, fid) = iprot.readFieldBegin()
20896 
      if ftype == TType.STOP:
20897 
        break
20898 
      if fid == 1:
20899 
        if ftype == TType.STRUCT:
20900 
          self.ex = TransactionServiceException()
20901 
          self.ex.read(iprot)
20902 
        else:
20903 
          iprot.skip(ftype)
20904 
      else:
20905 
        iprot.skip(ftype)
20906 
      iprot.readFieldEnd()
20907 
    iprot.readStructEnd()
20908 
 
20909 
  def write(self, oprot):
20910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20912 
      return
20913 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
20914 
    if self.ex is not None:
20915 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20916 
      self.ex.write(oprot)
20917 
      oprot.writeFieldEnd()
20918 
    oprot.writeFieldStop()
20919 
    oprot.writeStructEnd()
20920 
 
20921 
  def validate(self):
20922 
    return
20923 
 
20924 
 
20925 
  def __repr__(self):
20926 
    L = ['%s=%r' % (key, value)
20927 
      for key, value in self.__dict__.iteritems()]
20928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20929 
 
20930 
  def __eq__(self, other):
20931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20932 
 
20933 
  def __ne__(self, other):
20934 
    return not (self == other)
20935 
 
20936 
class getEBSSettlementDate_args:
20937 
  """
20938 
  Attributes:
20939 
   - settlementId
20940 
  """
20941 
 
20942 
  thrift_spec = (
20943 
    None, # 0
20944 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20945 
  )
20946 
 
20947 
  def __init__(self, settlementId=None,):
20948 
    self.settlementId = settlementId
20949 
 
20950 
  def read(self, iprot):
20951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20953 
      return
20954 
    iprot.readStructBegin()
20955 
    while True:
20956 
      (fname, ftype, fid) = iprot.readFieldBegin()
20957 
      if ftype == TType.STOP:
20958 
        break
20959 
      if fid == 1:
20960 
        if ftype == TType.I64:
20961 
          self.settlementId = iprot.readI64();
20962 
        else:
20963 
          iprot.skip(ftype)
20964 
      else:
20965 
        iprot.skip(ftype)
20966 
      iprot.readFieldEnd()
20967 
    iprot.readStructEnd()
20968 
 
20969 
  def write(self, oprot):
20970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20972 
      return
20973 
    oprot.writeStructBegin('getEBSSettlementDate_args')
20974 
    if self.settlementId is not None:
20975 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20976 
      oprot.writeI64(self.settlementId)
20977 
      oprot.writeFieldEnd()
20978 
    oprot.writeFieldStop()
20979 
    oprot.writeStructEnd()
20980 
 
20981 
  def validate(self):
20982 
    return
20983 
 
20984 
 
20985 
  def __repr__(self):
20986 
    L = ['%s=%r' % (key, value)
20987 
      for key, value in self.__dict__.iteritems()]
20988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20989 
 
20990 
  def __eq__(self, other):
20991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20992 
 
20993 
  def __ne__(self, other):
20994 
    return not (self == other)
20995 
 
20996 
class getEBSSettlementDate_result:
20997 
  """
20998 
  Attributes:
20999 
   - success
21000 
   - ex
21001 
  """
21002 
 
21003 
  thrift_spec = (
21004 
    (0, TType.I64, 'success', None, None, ), # 0
21005 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21006 
  )
21007 
 
21008 
  def __init__(self, success=None, ex=None,):
21009 
    self.success = success
21010 
    self.ex = ex
21011 
 
21012 
  def read(self, iprot):
21013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21015 
      return
21016 
    iprot.readStructBegin()
21017 
    while True:
21018 
      (fname, ftype, fid) = iprot.readFieldBegin()
21019 
      if ftype == TType.STOP:
21020 
        break
21021 
      if fid == 0:
21022 
        if ftype == TType.I64:
21023 
          self.success = iprot.readI64();
21024 
        else:
21025 
          iprot.skip(ftype)
21026 
      elif fid == 1:
21027 
        if ftype == TType.STRUCT:
21028 
          self.ex = TransactionServiceException()
21029 
          self.ex.read(iprot)
21030 
        else:
21031 
          iprot.skip(ftype)
21032 
      else:
21033 
        iprot.skip(ftype)
21034 
      iprot.readFieldEnd()
21035 
    iprot.readStructEnd()
21036 
 
21037 
  def write(self, oprot):
21038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21040 
      return
21041 
    oprot.writeStructBegin('getEBSSettlementDate_result')
21042 
    if self.success is not None:
21043 
      oprot.writeFieldBegin('success', TType.I64, 0)
21044 
      oprot.writeI64(self.success)
21045 
      oprot.writeFieldEnd()
21046 
    if self.ex is not None:
21047 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21048 
      self.ex.write(oprot)
21049 
      oprot.writeFieldEnd()
21050 
    oprot.writeFieldStop()
21051 
    oprot.writeStructEnd()
21052 
 
21053 
  def validate(self):
21054 
    return
21055 
 
21056 
 
21057 
  def __repr__(self):
21058 
    L = ['%s=%r' % (key, value)
21059 
      for key, value in self.__dict__.iteritems()]
21060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21061 
 
21062 
  def __eq__(self, other):
21063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21064 
 
21065 
  def __ne__(self, other):
21066 
    return not (self == other)
4715 varun.gupt 21067 
 
21068 
class getSettlementsByDate_args:
21069 
  """
21070 
  Attributes:
21071 
   - settlementDateFrom
21072 
   - settlementDateTo
21073 
   - isRefund
21074 
  """
21075 
 
21076 
  thrift_spec = (
21077 
    None, # 0
21078 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
21079 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
21080 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
21081 
  )
21082 
 
21083 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
21084 
    self.settlementDateFrom = settlementDateFrom
21085 
    self.settlementDateTo = settlementDateTo
21086 
    self.isRefund = isRefund
21087 
 
21088 
  def read(self, iprot):
21089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21091 
      return
21092 
    iprot.readStructBegin()
21093 
    while True:
21094 
      (fname, ftype, fid) = iprot.readFieldBegin()
21095 
      if ftype == TType.STOP:
21096 
        break
21097 
      if fid == 1:
21098 
        if ftype == TType.I64:
21099 
          self.settlementDateFrom = iprot.readI64();
21100 
        else:
21101 
          iprot.skip(ftype)
21102 
      elif fid == 2:
21103 
        if ftype == TType.I64:
21104 
          self.settlementDateTo = iprot.readI64();
21105 
        else:
21106 
          iprot.skip(ftype)
21107 
      elif fid == 3:
21108 
        if ftype == TType.BOOL:
21109 
          self.isRefund = iprot.readBool();
21110 
        else:
21111 
          iprot.skip(ftype)
21112 
      else:
21113 
        iprot.skip(ftype)
21114 
      iprot.readFieldEnd()
21115 
    iprot.readStructEnd()
21116 
 
21117 
  def write(self, oprot):
21118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21120 
      return
21121 
    oprot.writeStructBegin('getSettlementsByDate_args')
21122 
    if self.settlementDateFrom is not None:
21123 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
21124 
      oprot.writeI64(self.settlementDateFrom)
21125 
      oprot.writeFieldEnd()
21126 
    if self.settlementDateTo is not None:
21127 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
21128 
      oprot.writeI64(self.settlementDateTo)
21129 
      oprot.writeFieldEnd()
21130 
    if self.isRefund is not None:
21131 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
21132 
      oprot.writeBool(self.isRefund)
21133 
      oprot.writeFieldEnd()
21134 
    oprot.writeFieldStop()
21135 
    oprot.writeStructEnd()
21136 
 
21137 
  def validate(self):
21138 
    return
21139 
 
21140 
 
21141 
  def __repr__(self):
21142 
    L = ['%s=%r' % (key, value)
21143 
      for key, value in self.__dict__.iteritems()]
21144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21145 
 
21146 
  def __eq__(self, other):
21147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21148 
 
21149 
  def __ne__(self, other):
21150 
    return not (self == other)
21151 
 
21152 
class getSettlementsByDate_result:
21153 
  """
21154 
  Attributes:
21155 
   - success
21156 
   - ex
21157 
  """
21158 
 
21159 
  thrift_spec = (
21160 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
21161 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21162 
  )
21163 
 
21164 
  def __init__(self, success=None, ex=None,):
21165 
    self.success = success
21166 
    self.ex = ex
21167 
 
21168 
  def read(self, iprot):
21169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21171 
      return
21172 
    iprot.readStructBegin()
21173 
    while True:
21174 
      (fname, ftype, fid) = iprot.readFieldBegin()
21175 
      if ftype == TType.STOP:
21176 
        break
21177 
      if fid == 0:
21178 
        if ftype == TType.LIST:
21179 
          self.success = []
5031 varun.gupt 21180 
          (_etype474, _size471) = iprot.readListBegin()
21181 
          for _i475 in xrange(_size471):
21182 
            _elem476 = PaymentSettlement()
21183 
            _elem476.read(iprot)
21184 
            self.success.append(_elem476)
4715 varun.gupt 21185 
          iprot.readListEnd()
21186 
        else:
21187 
          iprot.skip(ftype)
21188 
      elif fid == 1:
21189 
        if ftype == TType.STRUCT:
21190 
          self.ex = TransactionServiceException()
21191 
          self.ex.read(iprot)
21192 
        else:
21193 
          iprot.skip(ftype)
21194 
      else:
21195 
        iprot.skip(ftype)
21196 
      iprot.readFieldEnd()
21197 
    iprot.readStructEnd()
21198 
 
21199 
  def write(self, oprot):
21200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21202 
      return
21203 
    oprot.writeStructBegin('getSettlementsByDate_result')
21204 
    if self.success is not None:
21205 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21206 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 21207 
      for iter477 in self.success:
21208 
        iter477.write(oprot)
4715 varun.gupt 21209 
      oprot.writeListEnd()
21210 
      oprot.writeFieldEnd()
21211 
    if self.ex is not None:
21212 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21213 
      self.ex.write(oprot)
21214 
      oprot.writeFieldEnd()
21215 
    oprot.writeFieldStop()
21216 
    oprot.writeStructEnd()
21217 
 
21218 
  def validate(self):
21219 
    return
21220 
 
21221 
 
21222 
  def __repr__(self):
21223 
    L = ['%s=%r' % (key, value)
21224 
      for key, value in self.__dict__.iteritems()]
21225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21226 
 
21227 
  def __eq__(self, other):
21228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21229 
 
21230 
  def __ne__(self, other):
21231 
    return not (self == other)
21232 
 
21233 
class getReshippedOrderIds_args:
21234 
  """
21235 
  Attributes:
21236 
   - orderIds
21237 
  """
21238 
 
21239 
  thrift_spec = (
21240 
    None, # 0
21241 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
21242 
  )
21243 
 
21244 
  def __init__(self, orderIds=None,):
21245 
    self.orderIds = orderIds
21246 
 
21247 
  def read(self, iprot):
21248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21250 
      return
21251 
    iprot.readStructBegin()
21252 
    while True:
21253 
      (fname, ftype, fid) = iprot.readFieldBegin()
21254 
      if ftype == TType.STOP:
21255 
        break
21256 
      if fid == 1:
21257 
        if ftype == TType.LIST:
21258 
          self.orderIds = []
5031 varun.gupt 21259 
          (_etype481, _size478) = iprot.readListBegin()
21260 
          for _i482 in xrange(_size478):
21261 
            _elem483 = iprot.readI64();
21262 
            self.orderIds.append(_elem483)
4715 varun.gupt 21263 
          iprot.readListEnd()
21264 
        else:
21265 
          iprot.skip(ftype)
21266 
      else:
21267 
        iprot.skip(ftype)
21268 
      iprot.readFieldEnd()
21269 
    iprot.readStructEnd()
21270 
 
21271 
  def write(self, oprot):
21272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21274 
      return
21275 
    oprot.writeStructBegin('getReshippedOrderIds_args')
21276 
    if self.orderIds is not None:
21277 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
21278 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5031 varun.gupt 21279 
      for iter484 in self.orderIds:
21280 
        oprot.writeI64(iter484)
4715 varun.gupt 21281 
      oprot.writeListEnd()
21282 
      oprot.writeFieldEnd()
21283 
    oprot.writeFieldStop()
21284 
    oprot.writeStructEnd()
21285 
 
21286 
  def validate(self):
21287 
    return
21288 
 
21289 
 
21290 
  def __repr__(self):
21291 
    L = ['%s=%r' % (key, value)
21292 
      for key, value in self.__dict__.iteritems()]
21293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21294 
 
21295 
  def __eq__(self, other):
21296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21297 
 
21298 
  def __ne__(self, other):
21299 
    return not (self == other)
21300 
 
21301 
class getReshippedOrderIds_result:
21302 
  """
21303 
  Attributes:
21304 
   - success
21305 
   - ex
21306 
  """
21307 
 
21308 
  thrift_spec = (
21309 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21310 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21311 
  )
21312 
 
21313 
  def __init__(self, success=None, ex=None,):
21314 
    self.success = success
21315 
    self.ex = ex
21316 
 
21317 
  def read(self, iprot):
21318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21320 
      return
21321 
    iprot.readStructBegin()
21322 
    while True:
21323 
      (fname, ftype, fid) = iprot.readFieldBegin()
21324 
      if ftype == TType.STOP:
21325 
        break
21326 
      if fid == 0:
21327 
        if ftype == TType.LIST:
21328 
          self.success = []
5031 varun.gupt 21329 
          (_etype488, _size485) = iprot.readListBegin()
21330 
          for _i489 in xrange(_size485):
21331 
            _elem490 = iprot.readI64();
21332 
            self.success.append(_elem490)
4715 varun.gupt 21333 
          iprot.readListEnd()
21334 
        else:
21335 
          iprot.skip(ftype)
21336 
      elif fid == 1:
21337 
        if ftype == TType.STRUCT:
21338 
          self.ex = TransactionServiceException()
21339 
          self.ex.read(iprot)
21340 
        else:
21341 
          iprot.skip(ftype)
21342 
      else:
21343 
        iprot.skip(ftype)
21344 
      iprot.readFieldEnd()
21345 
    iprot.readStructEnd()
21346 
 
21347 
  def write(self, oprot):
21348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21350 
      return
21351 
    oprot.writeStructBegin('getReshippedOrderIds_result')
21352 
    if self.success is not None:
21353 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21354 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 21355 
      for iter491 in self.success:
21356 
        oprot.writeI64(iter491)
4715 varun.gupt 21357 
      oprot.writeListEnd()
21358 
      oprot.writeFieldEnd()
21359 
    if self.ex is not None:
21360 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21361 
      self.ex.write(oprot)
21362 
      oprot.writeFieldEnd()
21363 
    oprot.writeFieldStop()
21364 
    oprot.writeStructEnd()
21365 
 
21366 
  def validate(self):
21367 
    return
21368 
 
21369 
 
21370 
  def __repr__(self):
21371 
    L = ['%s=%r' % (key, value)
21372 
      for key, value in self.__dict__.iteritems()]
21373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21374 
 
21375 
  def __eq__(self, other):
21376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21377 
 
21378 
  def __ne__(self, other):
21379 
    return not (self == other)
4757 mandeep.dh 21380 
 
21381 
class updateOrdersAsPORaised_args:
21382 
  """
21383 
  Attributes:
21384 
   - itemIdQuantityMap
21385 
   - purchaseOrderId
21386 
   - warehouseId
21387 
  """
21388 
 
21389 
  thrift_spec = (
21390 
    None, # 0
21391 
    (1, TType.MAP, 'itemIdQuantityMap', (TType.I64,None,TType.I64,None), None, ), # 1
21392 
    (2, TType.I64, 'purchaseOrderId', None, None, ), # 2
21393 
    (3, TType.I64, 'warehouseId', None, None, ), # 3
21394 
  )
21395 
 
21396 
  def __init__(self, itemIdQuantityMap=None, purchaseOrderId=None, warehouseId=None,):
21397 
    self.itemIdQuantityMap = itemIdQuantityMap
21398 
    self.purchaseOrderId = purchaseOrderId
21399 
    self.warehouseId = warehouseId
21400 
 
21401 
  def read(self, iprot):
21402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21404 
      return
21405 
    iprot.readStructBegin()
21406 
    while True:
21407 
      (fname, ftype, fid) = iprot.readFieldBegin()
21408 
      if ftype == TType.STOP:
21409 
        break
21410 
      if fid == 1:
21411 
        if ftype == TType.MAP:
21412 
          self.itemIdQuantityMap = {}
5031 varun.gupt 21413 
          (_ktype493, _vtype494, _size492 ) = iprot.readMapBegin()
21414 
          for _i496 in xrange(_size492):
21415 
            _key497 = iprot.readI64();
21416 
            _val498 = iprot.readI64();
21417 
            self.itemIdQuantityMap[_key497] = _val498
4757 mandeep.dh 21418 
          iprot.readMapEnd()
21419 
        else:
21420 
          iprot.skip(ftype)
21421 
      elif fid == 2:
21422 
        if ftype == TType.I64:
21423 
          self.purchaseOrderId = iprot.readI64();
21424 
        else:
21425 
          iprot.skip(ftype)
21426 
      elif fid == 3:
21427 
        if ftype == TType.I64:
21428 
          self.warehouseId = iprot.readI64();
21429 
        else:
21430 
          iprot.skip(ftype)
21431 
      else:
21432 
        iprot.skip(ftype)
21433 
      iprot.readFieldEnd()
21434 
    iprot.readStructEnd()
21435 
 
21436 
  def write(self, oprot):
21437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21439 
      return
21440 
    oprot.writeStructBegin('updateOrdersAsPORaised_args')
21441 
    if self.itemIdQuantityMap is not None:
21442 
      oprot.writeFieldBegin('itemIdQuantityMap', TType.MAP, 1)
21443 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemIdQuantityMap))
5031 varun.gupt 21444 
      for kiter499,viter500 in self.itemIdQuantityMap.items():
21445 
        oprot.writeI64(kiter499)
21446 
        oprot.writeI64(viter500)
4757 mandeep.dh 21447 
      oprot.writeMapEnd()
21448 
      oprot.writeFieldEnd()
21449 
    if self.purchaseOrderId is not None:
21450 
      oprot.writeFieldBegin('purchaseOrderId', TType.I64, 2)
21451 
      oprot.writeI64(self.purchaseOrderId)
21452 
      oprot.writeFieldEnd()
21453 
    if self.warehouseId is not None:
21454 
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
21455 
      oprot.writeI64(self.warehouseId)
21456 
      oprot.writeFieldEnd()
21457 
    oprot.writeFieldStop()
21458 
    oprot.writeStructEnd()
21459 
 
21460 
  def validate(self):
21461 
    return
21462 
 
21463 
 
21464 
  def __repr__(self):
21465 
    L = ['%s=%r' % (key, value)
21466 
      for key, value in self.__dict__.iteritems()]
21467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21468 
 
21469 
  def __eq__(self, other):
21470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21471 
 
21472 
  def __ne__(self, other):
21473 
    return not (self == other)
21474 
 
21475 
class updateOrdersAsPORaised_result:
21476 
  """
21477 
  Attributes:
21478 
   - ex
21479 
  """
21480 
 
21481 
  thrift_spec = (
21482 
    None, # 0
21483 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21484 
  )
21485 
 
21486 
  def __init__(self, ex=None,):
21487 
    self.ex = ex
21488 
 
21489 
  def read(self, iprot):
21490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21492 
      return
21493 
    iprot.readStructBegin()
21494 
    while True:
21495 
      (fname, ftype, fid) = iprot.readFieldBegin()
21496 
      if ftype == TType.STOP:
21497 
        break
21498 
      if fid == 1:
21499 
        if ftype == TType.STRUCT:
21500 
          self.ex = TransactionServiceException()
21501 
          self.ex.read(iprot)
21502 
        else:
21503 
          iprot.skip(ftype)
21504 
      else:
21505 
        iprot.skip(ftype)
21506 
      iprot.readFieldEnd()
21507 
    iprot.readStructEnd()
21508 
 
21509 
  def write(self, oprot):
21510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21512 
      return
21513 
    oprot.writeStructBegin('updateOrdersAsPORaised_result')
21514 
    if self.ex is not None:
21515 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21516 
      self.ex.write(oprot)
21517 
      oprot.writeFieldEnd()
21518 
    oprot.writeFieldStop()
21519 
    oprot.writeStructEnd()
21520 
 
21521 
  def validate(self):
21522 
    return
21523 
 
21524 
 
21525 
  def __repr__(self):
21526 
    L = ['%s=%r' % (key, value)
21527 
      for key, value in self.__dict__.iteritems()]
21528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21529 
 
21530 
  def __eq__(self, other):
21531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21532 
 
21533 
  def __ne__(self, other):
21534 
    return not (self == other)
4875 varun.gupt 21535 
 
21536 
class getOrdersWhereVendorNotPaid_args:
21537 
  """
21538 
  Attributes:
21539 
   - vendorId
21540 
  """
21541 
 
21542 
  thrift_spec = (
21543 
    None, # 0
21544 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21545 
  )
21546 
 
21547 
  def __init__(self, vendorId=None,):
21548 
    self.vendorId = vendorId
21549 
 
21550 
  def read(self, iprot):
21551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21553 
      return
21554 
    iprot.readStructBegin()
21555 
    while True:
21556 
      (fname, ftype, fid) = iprot.readFieldBegin()
21557 
      if ftype == TType.STOP:
21558 
        break
21559 
      if fid == 1:
21560 
        if ftype == TType.I64:
21561 
          self.vendorId = iprot.readI64();
21562 
        else:
21563 
          iprot.skip(ftype)
21564 
      else:
21565 
        iprot.skip(ftype)
21566 
      iprot.readFieldEnd()
21567 
    iprot.readStructEnd()
21568 
 
21569 
  def write(self, oprot):
21570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21572 
      return
21573 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_args')
21574 
    if self.vendorId is not None:
21575 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21576 
      oprot.writeI64(self.vendorId)
21577 
      oprot.writeFieldEnd()
21578 
    oprot.writeFieldStop()
21579 
    oprot.writeStructEnd()
21580 
 
21581 
  def validate(self):
21582 
    return
21583 
 
21584 
 
21585 
  def __repr__(self):
21586 
    L = ['%s=%r' % (key, value)
21587 
      for key, value in self.__dict__.iteritems()]
21588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21589 
 
21590 
  def __eq__(self, other):
21591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21592 
 
21593 
  def __ne__(self, other):
21594 
    return not (self == other)
21595 
 
21596 
class getOrdersWhereVendorNotPaid_result:
21597 
  """
21598 
  Attributes:
21599 
   - success
21600 
   - ex
21601 
  """
21602 
 
21603 
  thrift_spec = (
21604 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21605 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21606 
  )
21607 
 
21608 
  def __init__(self, success=None, ex=None,):
21609 
    self.success = success
21610 
    self.ex = ex
21611 
 
21612 
  def read(self, iprot):
21613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21615 
      return
21616 
    iprot.readStructBegin()
21617 
    while True:
21618 
      (fname, ftype, fid) = iprot.readFieldBegin()
21619 
      if ftype == TType.STOP:
21620 
        break
21621 
      if fid == 0:
21622 
        if ftype == TType.LIST:
21623 
          self.success = []
5031 varun.gupt 21624 
          (_etype504, _size501) = iprot.readListBegin()
21625 
          for _i505 in xrange(_size501):
21626 
            _elem506 = Order()
21627 
            _elem506.read(iprot)
21628 
            self.success.append(_elem506)
4875 varun.gupt 21629 
          iprot.readListEnd()
21630 
        else:
21631 
          iprot.skip(ftype)
21632 
      elif fid == 1:
21633 
        if ftype == TType.STRUCT:
21634 
          self.ex = TransactionServiceException()
21635 
          self.ex.read(iprot)
21636 
        else:
21637 
          iprot.skip(ftype)
21638 
      else:
21639 
        iprot.skip(ftype)
21640 
      iprot.readFieldEnd()
21641 
    iprot.readStructEnd()
21642 
 
21643 
  def write(self, oprot):
21644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21646 
      return
21647 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_result')
21648 
    if self.success is not None:
21649 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21650 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 21651 
      for iter507 in self.success:
21652 
        iter507.write(oprot)
4875 varun.gupt 21653 
      oprot.writeListEnd()
21654 
      oprot.writeFieldEnd()
21655 
    if self.ex is not None:
21656 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21657 
      self.ex.write(oprot)
21658 
      oprot.writeFieldEnd()
21659 
    oprot.writeFieldStop()
21660 
    oprot.writeStructEnd()
21661 
 
21662 
  def validate(self):
21663 
    return
21664 
 
21665 
 
21666 
  def __repr__(self):
21667 
    L = ['%s=%r' % (key, value)
21668 
      for key, value in self.__dict__.iteritems()]
21669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21670 
 
21671 
  def __eq__(self, other):
21672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21673 
 
21674 
  def __ne__(self, other):
21675 
    return not (self == other)
5031 varun.gupt 21676 
 
21677 
class getStatusDistributionOfOrders_args:
21678 
  """
21679 
  Attributes:
21680 
   - startDate
21681 
   - endDate
21682 
  """
21683 
 
21684 
  thrift_spec = (
21685 
    None, # 0
21686 
    (1, TType.I64, 'startDate', None, None, ), # 1
21687 
    (2, TType.I64, 'endDate', None, None, ), # 2
21688 
  )
21689 
 
21690 
  def __init__(self, startDate=None, endDate=None,):
21691 
    self.startDate = startDate
21692 
    self.endDate = endDate
21693 
 
21694 
  def read(self, iprot):
21695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21697 
      return
21698 
    iprot.readStructBegin()
21699 
    while True:
21700 
      (fname, ftype, fid) = iprot.readFieldBegin()
21701 
      if ftype == TType.STOP:
21702 
        break
21703 
      if fid == 1:
21704 
        if ftype == TType.I64:
21705 
          self.startDate = iprot.readI64();
21706 
        else:
21707 
          iprot.skip(ftype)
21708 
      elif fid == 2:
21709 
        if ftype == TType.I64:
21710 
          self.endDate = iprot.readI64();
21711 
        else:
21712 
          iprot.skip(ftype)
21713 
      else:
21714 
        iprot.skip(ftype)
21715 
      iprot.readFieldEnd()
21716 
    iprot.readStructEnd()
21717 
 
21718 
  def write(self, oprot):
21719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21721 
      return
21722 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
21723 
    if self.startDate is not None:
21724 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
21725 
      oprot.writeI64(self.startDate)
21726 
      oprot.writeFieldEnd()
21727 
    if self.endDate is not None:
21728 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
21729 
      oprot.writeI64(self.endDate)
21730 
      oprot.writeFieldEnd()
21731 
    oprot.writeFieldStop()
21732 
    oprot.writeStructEnd()
21733 
 
21734 
  def validate(self):
21735 
    return
21736 
 
21737 
 
21738 
  def __repr__(self):
21739 
    L = ['%s=%r' % (key, value)
21740 
      for key, value in self.__dict__.iteritems()]
21741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21742 
 
21743 
  def __eq__(self, other):
21744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21745 
 
21746 
  def __ne__(self, other):
21747 
    return not (self == other)
21748 
 
21749 
class getStatusDistributionOfOrders_result:
21750 
  """
21751 
  Attributes:
21752 
   - success
21753 
   - ex
21754 
  """
21755 
 
21756 
  thrift_spec = (
21757 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
21758 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21759 
  )
21760 
 
21761 
  def __init__(self, success=None, ex=None,):
21762 
    self.success = success
21763 
    self.ex = ex
21764 
 
21765 
  def read(self, iprot):
21766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21768 
      return
21769 
    iprot.readStructBegin()
21770 
    while True:
21771 
      (fname, ftype, fid) = iprot.readFieldBegin()
21772 
      if ftype == TType.STOP:
21773 
        break
21774 
      if fid == 0:
21775 
        if ftype == TType.MAP:
21776 
          self.success = {}
21777 
          (_ktype509, _vtype510, _size508 ) = iprot.readMapBegin()
21778 
          for _i512 in xrange(_size508):
21779 
            _key513 = iprot.readI64();
21780 
            _val514 = iprot.readI64();
21781 
            self.success[_key513] = _val514
21782 
          iprot.readMapEnd()
21783 
        else:
21784 
          iprot.skip(ftype)
21785 
      elif fid == 1:
21786 
        if ftype == TType.STRUCT:
21787 
          self.ex = TransactionServiceException()
21788 
          self.ex.read(iprot)
21789 
        else:
21790 
          iprot.skip(ftype)
21791 
      else:
21792 
        iprot.skip(ftype)
21793 
      iprot.readFieldEnd()
21794 
    iprot.readStructEnd()
21795 
 
21796 
  def write(self, oprot):
21797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21799 
      return
21800 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
21801 
    if self.success is not None:
21802 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21803 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
21804 
      for kiter515,viter516 in self.success.items():
21805 
        oprot.writeI64(kiter515)
21806 
        oprot.writeI64(viter516)
21807 
      oprot.writeMapEnd()
21808 
      oprot.writeFieldEnd()
21809 
    if self.ex is not None:
21810 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21811 
      self.ex.write(oprot)
21812 
      oprot.writeFieldEnd()
21813 
    oprot.writeFieldStop()
21814 
    oprot.writeStructEnd()
21815 
 
21816 
  def validate(self):
21817 
    return
21818 
 
21819 
 
21820 
  def __repr__(self):
21821 
    L = ['%s=%r' % (key, value)
21822 
      for key, value in self.__dict__.iteritems()]
21823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21824 
 
21825 
  def __eq__(self, other):
21826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21827 
 
21828 
  def __ne__(self, other):
21829 
    return not (self == other)
5067 varun.gupt 21830 
 
21831 
class getOrderIdsForStatus_args:
21832 
  """
21833 
  Attributes:
21834 
   - status
21835 
   - startDatetime
21836 
   - endDatetime
21837 
  """
21838 
 
21839 
  thrift_spec = (
21840 
    None, # 0
21841 
    (1, TType.I64, 'status', None, None, ), # 1
21842 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
21843 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
21844 
  )
21845 
 
21846 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
21847 
    self.status = status
21848 
    self.startDatetime = startDatetime
21849 
    self.endDatetime = endDatetime
21850 
 
21851 
  def read(self, iprot):
21852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21854 
      return
21855 
    iprot.readStructBegin()
21856 
    while True:
21857 
      (fname, ftype, fid) = iprot.readFieldBegin()
21858 
      if ftype == TType.STOP:
21859 
        break
21860 
      if fid == 1:
21861 
        if ftype == TType.I64:
21862 
          self.status = iprot.readI64();
21863 
        else:
21864 
          iprot.skip(ftype)
21865 
      elif fid == 2:
21866 
        if ftype == TType.I64:
21867 
          self.startDatetime = iprot.readI64();
21868 
        else:
21869 
          iprot.skip(ftype)
21870 
      elif fid == 3:
21871 
        if ftype == TType.I64:
21872 
          self.endDatetime = iprot.readI64();
21873 
        else:
21874 
          iprot.skip(ftype)
21875 
      else:
21876 
        iprot.skip(ftype)
21877 
      iprot.readFieldEnd()
21878 
    iprot.readStructEnd()
21879 
 
21880 
  def write(self, oprot):
21881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21883 
      return
21884 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
21885 
    if self.status is not None:
21886 
      oprot.writeFieldBegin('status', TType.I64, 1)
21887 
      oprot.writeI64(self.status)
21888 
      oprot.writeFieldEnd()
21889 
    if self.startDatetime is not None:
21890 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
21891 
      oprot.writeI64(self.startDatetime)
21892 
      oprot.writeFieldEnd()
21893 
    if self.endDatetime is not None:
21894 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
21895 
      oprot.writeI64(self.endDatetime)
21896 
      oprot.writeFieldEnd()
21897 
    oprot.writeFieldStop()
21898 
    oprot.writeStructEnd()
21899 
 
21900 
  def validate(self):
21901 
    return
21902 
 
21903 
 
21904 
  def __repr__(self):
21905 
    L = ['%s=%r' % (key, value)
21906 
      for key, value in self.__dict__.iteritems()]
21907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21908 
 
21909 
  def __eq__(self, other):
21910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21911 
 
21912 
  def __ne__(self, other):
21913 
    return not (self == other)
21914 
 
21915 
class getOrderIdsForStatus_result:
21916 
  """
21917 
  Attributes:
21918 
   - success
21919 
   - ex
21920 
  """
21921 
 
21922 
  thrift_spec = (
21923 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21924 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21925 
  )
21926 
 
21927 
  def __init__(self, success=None, ex=None,):
21928 
    self.success = success
21929 
    self.ex = ex
21930 
 
21931 
  def read(self, iprot):
21932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21934 
      return
21935 
    iprot.readStructBegin()
21936 
    while True:
21937 
      (fname, ftype, fid) = iprot.readFieldBegin()
21938 
      if ftype == TType.STOP:
21939 
        break
21940 
      if fid == 0:
21941 
        if ftype == TType.LIST:
21942 
          self.success = []
21943 
          (_etype520, _size517) = iprot.readListBegin()
21944 
          for _i521 in xrange(_size517):
21945 
            _elem522 = iprot.readI64();
21946 
            self.success.append(_elem522)
21947 
          iprot.readListEnd()
21948 
        else:
21949 
          iprot.skip(ftype)
21950 
      elif fid == 1:
21951 
        if ftype == TType.STRUCT:
21952 
          self.ex = TransactionServiceException()
21953 
          self.ex.read(iprot)
21954 
        else:
21955 
          iprot.skip(ftype)
21956 
      else:
21957 
        iprot.skip(ftype)
21958 
      iprot.readFieldEnd()
21959 
    iprot.readStructEnd()
21960 
 
21961 
  def write(self, oprot):
21962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21964 
      return
21965 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
21966 
    if self.success is not None:
21967 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21968 
      oprot.writeListBegin(TType.I64, len(self.success))
21969 
      for iter523 in self.success:
21970 
        oprot.writeI64(iter523)
21971 
      oprot.writeListEnd()
21972 
      oprot.writeFieldEnd()
21973 
    if self.ex is not None:
21974 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21975 
      self.ex.write(oprot)
21976 
      oprot.writeFieldEnd()
21977 
    oprot.writeFieldStop()
21978 
    oprot.writeStructEnd()
21979 
 
21980 
  def validate(self):
21981 
    return
21982 
 
21983 
 
21984 
  def __repr__(self):
21985 
    L = ['%s=%r' % (key, value)
21986 
      for key, value in self.__dict__.iteritems()]
21987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21988 
 
21989 
  def __eq__(self, other):
21990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21991 
 
21992 
  def __ne__(self, other):
21993 
    return not (self == other)
5099 varun.gupt 21994 
 
21995 
class updateOrderAsPaidToVendor_args:
21996 
  """
21997 
  Attributes:
21998 
   - orderId
21999 
  """
22000 
 
22001 
  thrift_spec = (
22002 
    None, # 0
22003 
    (1, TType.I64, 'orderId', None, None, ), # 1
22004 
  )
22005 
 
22006 
  def __init__(self, orderId=None,):
22007 
    self.orderId = orderId
22008 
 
22009 
  def read(self, iprot):
22010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22012 
      return
22013 
    iprot.readStructBegin()
22014 
    while True:
22015 
      (fname, ftype, fid) = iprot.readFieldBegin()
22016 
      if ftype == TType.STOP:
22017 
        break
22018 
      if fid == 1:
22019 
        if ftype == TType.I64:
22020 
          self.orderId = iprot.readI64();
22021 
        else:
22022 
          iprot.skip(ftype)
22023 
      else:
22024 
        iprot.skip(ftype)
22025 
      iprot.readFieldEnd()
22026 
    iprot.readStructEnd()
22027 
 
22028 
  def write(self, oprot):
22029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22031 
      return
22032 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
22033 
    if self.orderId is not None:
22034 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22035 
      oprot.writeI64(self.orderId)
22036 
      oprot.writeFieldEnd()
22037 
    oprot.writeFieldStop()
22038 
    oprot.writeStructEnd()
22039 
 
22040 
  def validate(self):
22041 
    return
22042 
 
22043 
 
22044 
  def __repr__(self):
22045 
    L = ['%s=%r' % (key, value)
22046 
      for key, value in self.__dict__.iteritems()]
22047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22048 
 
22049 
  def __eq__(self, other):
22050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22051 
 
22052 
  def __ne__(self, other):
22053 
    return not (self == other)
22054 
 
22055 
class updateOrderAsPaidToVendor_result:
22056 
  """
22057 
  Attributes:
22058 
   - ex
22059 
  """
22060 
 
22061 
  thrift_spec = (
22062 
    None, # 0
22063 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22064 
  )
22065 
 
22066 
  def __init__(self, ex=None,):
22067 
    self.ex = ex
22068 
 
22069 
  def read(self, iprot):
22070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22072 
      return
22073 
    iprot.readStructBegin()
22074 
    while True:
22075 
      (fname, ftype, fid) = iprot.readFieldBegin()
22076 
      if ftype == TType.STOP:
22077 
        break
22078 
      if fid == 1:
22079 
        if ftype == TType.STRUCT:
22080 
          self.ex = TransactionServiceException()
22081 
          self.ex.read(iprot)
22082 
        else:
22083 
          iprot.skip(ftype)
22084 
      else:
22085 
        iprot.skip(ftype)
22086 
      iprot.readFieldEnd()
22087 
    iprot.readStructEnd()
22088 
 
22089 
  def write(self, oprot):
22090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22092 
      return
22093 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
22094 
    if self.ex is not None:
22095 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22096 
      self.ex.write(oprot)
22097 
      oprot.writeFieldEnd()
22098 
    oprot.writeFieldStop()
22099 
    oprot.writeStructEnd()
22100 
 
22101 
  def validate(self):
22102 
    return
22103 
 
22104 
 
22105 
  def __repr__(self):
22106 
    L = ['%s=%r' % (key, value)
22107 
      for key, value in self.__dict__.iteritems()]
22108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22109 
 
22110 
  def __eq__(self, other):
22111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22112 
 
22113 
  def __ne__(self, other):
22114 
    return not (self == other)