Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
58 
  def changeTransactionStatus(self, transactionId, status, description):
59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
64 
    """
65 
    pass
66 
 
1398 varun.gupt 67 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 68 
    """
69 
    Parameters:
70 
     - transactionId
71 
    """
72 
    pass
73 
 
4801 anupam.sin 74 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 75 
    """
76 
    Parameters:
4801 anupam.sin 77 
     - statuses
483 rajveer 78 
     - from_date
79 
     - to_date
80 
     - warehouse_id
94 ashish 81 
    """
82 
    pass
83 
 
4133 chandransh 84 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
85 
    """
86 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
87 
    Pass the status as null and the limit as 0 to ignore them.
88 
 
89 
    Parameters:
90 
     - statuses
91 
     - offset
92 
     - limit
93 
     - warehouse_id
94 
    """
95 
    pass
96 
 
97 
  def getOrderCount(self, statuses, warehouseId):
98 
    """
99 
    Returns the count of orders with the given statuses assigned to the given warehouse.
100 
 
101 
    Parameters:
102 
     - statuses
103 
     - warehouseId
104 
    """
105 
    pass
106 
 
999 varun.gupt 107 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
108 
    """
1132 chandransh 109 
    Returns orders within a range of their billing dates
3431 rajveer 110 
 
999 varun.gupt 111 
    Parameters:
112 
     - status
113 
     - start_billing_date
114 
     - end_billing_date
115 
     - warehouse_id
116 
    """
117 
    pass
118 
 
3451 chandransh 119 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 120 
    """
121 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 122 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
123 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 124 
 
3427 chandransh 125 
    Parameters:
126 
     - fromShippingDate
127 
     - toShippingDate
128 
     - providerId
129 
     - warehouseId
3451 chandransh 130 
     - cod
3427 chandransh 131 
    """
132 
    pass
133 
 
1382 varun.gupt 134 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
135 
    """
136 
    Returns order ids for orders which can be returned
3431 rajveer 137 
 
1382 varun.gupt 138 
    Parameters:
139 
     - customer_id
140 
     - limit
141 
    """
142 
    pass
143 
 
144 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
145 
    """
146 
    Returns order ids for orders which can be cancelled
3431 rajveer 147 
 
1382 varun.gupt 148 
    Parameters:
149 
     - customer_id
150 
     - limit
151 
    """
152 
    pass
153 
 
483 rajveer 154 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 155 
    """
156 
    Parameters:
483 rajveer 157 
     - orderId
158 
     - status
159 
     - description
94 ashish 160 
    """
161 
    pass
162 
 
1528 ankur.sing 163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 164 
    """
1528 ankur.sing 165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
166 
    only user who owns the transaction can view its order details.
3431 rajveer 167 
 
94 ashish 168 
    Parameters:
169 
     - transactionId
1528 ankur.sing 170 
     - customerId
94 ashish 171 
    """
172 
    pass
173 
 
3014 chandransh 174 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 175 
    """
3014 chandransh 176 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
177 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 178 
 
94 ashish 179 
    Parameters:
483 rajveer 180 
     - customerId
181 
     - from_date
182 
     - to_date
3014 chandransh 183 
     - statuses
94 ashish 184 
    """
185 
    pass
186 
 
483 rajveer 187 
  def createOrder(self, order):
94 ashish 188 
    """
189 
    Parameters:
483 rajveer 190 
     - order
94 ashish 191 
    """
192 
    pass
193 
 
483 rajveer 194 
  def getOrder(self, id):
94 ashish 195 
    """
196 
    Parameters:
483 rajveer 197 
     - id
94 ashish 198 
    """
199 
    pass
200 
 
483 rajveer 201 
  def getLineItemsForOrder(self, orderId):
94 ashish 202 
    """
203 
    Parameters:
483 rajveer 204 
     - orderId
94 ashish 205 
    """
206 
    pass
207 
 
4999 phani.kuma 208 
  def getOrderList(self, order_ids):
209 
    """
210 
    Parameters:
211 
     - order_ids
212 
    """
213 
    pass
214 
 
1528 ankur.sing 215 
  def getOrderForCustomer(self, orderId, customerId):
216 
    """
217 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
218 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 219 
 
1528 ankur.sing 220 
    Parameters:
221 
     - orderId
222 
     - customerId
223 
    """
224 
    pass
225 
 
4444 rajveer 226 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 227 
    """
228 
    Parameters:
4394 rajveer 229 
     - type
4444 rajveer 230 
     - warehouseId
4394 rajveer 231 
     - status
232 
     - timestamp
3064 chandransh 233 
    """
234 
    pass
235 
 
4444 rajveer 236 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 237 
    """
238 
    Parameters:
239 
     - type
4444 rajveer 240 
     - warehouseId
4394 rajveer 241 
     - description
3064 chandransh 242 
    """
243 
    pass
244 
 
4444 rajveer 245 
  def markAlertsAsSeen(self, warehouseId):
246 
    """
247 
    Parameters:
248 
     - warehouseId
249 
    """
250 
    pass
251 
 
3064 chandransh 252 
  def getValidOrderCount(self, ):
253 
    """
254 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
255 
    """
256 
    pass
257 
 
258 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
259 
    """
260 
    Returns the number of distinct customers who have done successful transactions
261 
    """
262 
    pass
263 
 
264 
  def getValidOrdersAmountRange(self, ):
265 
    """
266 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
267 
    List contains two values, first minimum amount and second maximum amount.
268 
    """
269 
    pass
270 
 
271 
  def getValidOrders(self, limit):
272 
    """
273 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
274 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 275 
 
3064 chandransh 276 
    Parameters:
277 
     - limit
278 
    """
279 
    pass
280 
 
1220 chandransh 281 
  def batchOrders(self, warehouseId):
282 
    """
283 
    Create a batch of all the pending orders for the given warehouse.
284 
    The returned list is orderd by created_timestamp.
285 
    If there are no pending orders, an empty list is returned.
3431 rajveer 286 
 
1220 chandransh 287 
    Parameters:
288 
     - warehouseId
289 
    """
290 
    pass
291 
 
1208 chandransh 292 
  def markOrderAsOutOfStock(self, orderId):
293 
    """
294 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 295 
 
1208 chandransh 296 
    Parameters:
297 
     - orderId
298 
    """
299 
    pass
300 
 
3064 chandransh 301 
  def verifyOrder(self, orderId):
759 chandransh 302 
    """
3064 chandransh 303 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
304 
    timestamp. It is intended to be used for COD orders but can be harmlessly
305 
    used for all other orders as well.
306 
    Throws an exception if no such order exists.
3431 rajveer 307 
 
759 chandransh 308 
    Parameters:
3064 chandransh 309 
     - orderId
310 
    """
311 
    pass
312 
 
313 
  def acceptOrder(self, orderId):
314 
    """
315 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
316 
    given order is not a COD order, it also captures the payment if the same has
317 
    not been captured.
318 
    Throws an exception if no such order exists.
3431 rajveer 319 
 
3064 chandransh 320 
    Parameters:
321 
     - orderId
322 
    """
323 
    pass
324 
 
5110 mandeep.dh 325 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 326 
    """
327 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 328 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 329 
    the IMEI no. if a -1 is supplied.
330 
    Also, it generates an invoice number for the order, marks the order as
331 
    BILLED and sets the billing timestamp.
332 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 333 
 
3064 chandransh 334 
    Parameters:
335 
     - orderId
4283 anupam.sin 336 
     - invoice_number
4658 mandeep.dh 337 
     - serialNumber
3064 chandransh 338 
     - itemNumber
4283 anupam.sin 339 
     - billed_by
340 
     - jacketNumber
3064 chandransh 341 
     - billingType
5110 mandeep.dh 342 
     - fulfilmentWarehouseId
4763 rajveer 343 
     - authorize
3064 chandransh 344 
    """
345 
    pass
346 
 
4763 rajveer 347 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 348 
    """
349 
    Add the invoice number to the order.
350 
 
351 
    Parameters:
352 
     - orderId
353 
     - invoiceNumber
4763 rajveer 354 
     - color
4579 rajveer 355 
    """
356 
    pass
357 
 
4910 phani.kuma 358 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 359 
    """
360 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 361 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 362 
 
363 
    Parameters:
364 
     - warehouseId
365 
     - providerId
366 
     - cod
4910 phani.kuma 367 
     - orderIds
4410 rajveer 368 
    """
369 
    pass
370 
 
4910 phani.kuma 371 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 372 
    """
4910 phani.kuma 373 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
374 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 375 
 
3064 chandransh 376 
    Parameters:
759 chandransh 377 
     - providerId
4910 phani.kuma 378 
     - pickupDetails
759 chandransh 379 
    """
380 
    pass
381 
 
4910 phani.kuma 382 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 383 
    """
384 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 385 
 
1113 chandransh 386 
    Parameters:
387 
     - providerId
388 
    """
389 
    pass
390 
 
1132 chandransh 391 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
392 
    """
393 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
394 
    the name of the receiver.
395 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 396 
 
1132 chandransh 397 
    Parameters:
398 
     - providerId
399 
     - deliveredOrders
400 
    """
401 
    pass
402 
 
4910 phani.kuma 403 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 404 
    """
4910 phani.kuma 405 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 406 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 407 
 
1135 chandransh 408 
    Parameters:
409 
     - providerId
410 
     - returnedOrders
411 
    """
412 
    pass
413 
 
4910 phani.kuma 414 
  def getRTOrders(self, providerId):
415 
    """
416 
    Returns a list of orders that were returned by courier.
417 
 
418 
    Parameters:
419 
     - providerId
420 
    """
421 
    pass
422 
 
1246 chandransh 423 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
424 
    """
425 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 426 
 
1246 chandransh 427 
    Parameters:
428 
     - providerId
429 
     - undeliveredOrders
430 
    """
431 
    pass
432 
 
4910 phani.kuma 433 
  def getNonDeliveredOrdersbyCourier(self, providerId):
434 
    """
435 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
436 
 
437 
    Parameters:
438 
     - providerId
439 
    """
440 
    pass
441 
 
442 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
443 
    """
444 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
445 
 
446 
    Parameters:
447 
     - providerId
448 
     - local_connected_orders
449 
    """
450 
    pass
451 
 
452 
  def getOrdersNotLocalConnected(self, providerId):
453 
    """
454 
    Returns a list of orders that were picked up or shipped but pending local connection.
455 
 
456 
    Parameters:
457 
     - providerId
458 
    """
459 
    pass
460 
 
461 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
462 
    """
463 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
464 
 
465 
    Parameters:
466 
     - providerId
467 
     - destination_city_reached_orders
468 
    """
469 
    pass
470 
 
471 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
472 
    """
473 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
474 
 
475 
    Parameters:
476 
     - providerId
477 
     - first_atdl_orders
478 
    """
479 
    pass
480 
 
1408 ankur.sing 481 
  def getUndeliveredOrders(self, providerId, warehouseId):
482 
    """
483 
    Returns the list of orders whose delivery time has passed but have not been
484 
    delivered yet for the given provider and warehouse. To get a complete list of
485 
    undelivered orders, pass them as -1.
486 
    Returns an empty list if no such orders exist.
3431 rajveer 487 
 
1408 ankur.sing 488 
    Parameters:
489 
     - providerId
490 
     - warehouseId
491 
    """
492 
    pass
493 
 
4783 phani.kuma 494 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
495 
    """
496 
    Returns the list of orders whose expected delivery date has passed but have not been
497 
    delivered yet.
498 
    Returns an empty list if no such orders exist.
499 
    """
500 
    pass
501 
 
2536 chandransh 502 
  def toggleDOAFlag(self, orderId):
503 
    """
504 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
505 
    Returns the final flag status.
506 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 507 
 
2536 chandransh 508 
    Parameters:
509 
     - orderId
510 
    """
511 
    pass
1886 ankur.sing 512 
 
4712 rajveer 513 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
514 
    """
515 
    Parameters:
516 
     - orderId
517 
     - deliveryTimestamp
518 
     - receiver
519 
    """
520 
    pass
521 
 
4454 rajveer 522 
  def markOrderDoaRequestReceived(self, orderId):
523 
    """
524 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
525 
 
526 
    Parameters:
527 
     - orderId
528 
    """
529 
    pass
530 
 
531 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
532 
    """
533 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
534 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
535 
 
536 
    Parameters:
537 
     - orderId
538 
     - isAuthorized
539 
    """
540 
    pass
541 
 
4488 rajveer 542 
  def markOrderReturnRequestReceived(self, orderId):
543 
    """
544 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
545 
 
546 
    Parameters:
547 
     - orderId
548 
    """
549 
    pass
550 
 
551 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
552 
    """
553 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
554 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
555 
 
556 
    Parameters:
557 
     - orderId
558 
     - isAuthorized
559 
    """
560 
    pass
561 
 
4579 rajveer 562 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 563 
    """
564 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 565 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
566 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 567 
    For any other status, it returns false.
568 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 569 
 
2536 chandransh 570 
    Parameters:
571 
     - orderId
4579 rajveer 572 
     - providerId
2536 chandransh 573 
    """
574 
    pass
575 
 
4602 rajveer 576 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 577 
    """
4452 rajveer 578 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 579 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
580 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
581 
    	3. Returns true
2591 chandransh 582 
    If the order is in any other status, it returns false.
2536 chandransh 583 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 584 
 
2536 chandransh 585 
    Parameters:
586 
     - orderId
587 
     - pickupNumber
4602 rajveer 588 
     - providerId
2536 chandransh 589 
    """
590 
    pass
591 
 
2764 chandransh 592 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
593 
    """
594 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 595 
 
2764 chandransh 596 
    Parameters:
597 
     - providerId
598 
     - pickupDetails
599 
    """
600 
    pass
601 
 
4910 phani.kuma 602 
  def getDoasNotPickedUp(self, providerId):
603 
    """
604 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
605 
 
606 
    Parameters:
607 
     - providerId
608 
    """
609 
    pass
610 
 
4741 phani.kuma 611 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
612 
    """
613 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
614 
 
615 
    Parameters:
616 
     - providerId
617 
     - pickupDetails
618 
    """
619 
    pass
620 
 
4910 phani.kuma 621 
  def getReturnOrdersNotPickedUp(self, providerId):
622 
    """
623 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
624 
 
625 
    Parameters:
626 
     - providerId
627 
    """
628 
    pass
629 
 
4479 rajveer 630 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 631 
    """
4452 rajveer 632 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 633 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 634 
    If the order is in any other state, it returns false.
635 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 636 
 
2591 chandransh 637 
    Parameters:
638 
     - orderId
4479 rajveer 639 
     - receiveCondition
2591 chandransh 640 
    """
641 
    pass
2536 chandransh 642 
 
2591 chandransh 643 
  def validateDoa(self, orderId, isValid):
644 
    """
4452 rajveer 645 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 646 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 647 
    If the order is in any other state, it returns false.
648 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 649 
 
2591 chandransh 650 
    Parameters:
651 
     - orderId
652 
     - isValid
653 
    """
654 
    pass
655 
 
4495 rajveer 656 
  def validateReturnProduct(self, orderId, isUsable):
657 
    """
658 
    Parameters:
659 
     - orderId
660 
     - isUsable
661 
    """
662 
    pass
663 
 
2616 chandransh 664 
  def reshipOrder(self, orderId):
665 
    """
4484 rajveer 666 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 667 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 668 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 669 
 
670 
    If the order is in DOA_CERT_VALID state, it does the following:
671 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
672 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 673 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 674 
 
2616 chandransh 675 
    Returns the id of the newly created order.
3431 rajveer 676 
 
2616 chandransh 677 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 678 
 
2616 chandransh 679 
    Parameters:
680 
     - orderId
681 
    """
682 
    pass
2591 chandransh 683 
 
3226 chandransh 684 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 685 
    """
4484 rajveer 686 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 687 
    	1. Creates a refund request for batch processing.
688 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 689 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 690 
 
2616 chandransh 691 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
692 
    	1. Creates a refund request for batch processing.
3226 chandransh 693 
    	2. Cancels the reservation of the item in the warehouse.
694 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 695 
 
3226 chandransh 696 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
697 
    	1. Cancels the reservation of the item in the warehouse.
698 
    	2. Marks the current order as CANCELED.
699 
 
700 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
701 
 
2616 chandransh 702 
    Returns True if it is successful, False otherwise.
3431 rajveer 703 
 
2616 chandransh 704 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 705 
 
2616 chandransh 706 
    Parameters:
707 
     - orderId
3226 chandransh 708 
     - refundedBy
709 
     - reason
2616 chandransh 710 
    """
711 
    pass
712 
 
2690 chandransh 713 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
714 
    """
715 
    Get all return orders created between the from and to dates for the given warehouse.
716 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 717 
 
2690 chandransh 718 
    Parameters:
719 
     - warehouseId
720 
     - fromDate
721 
     - toDate
722 
    """
723 
    pass
2616 chandransh 724 
 
2700 chandransh 725 
  def getReturnOrder(self, id):
726 
    """
727 
    Returns the ReturnOrder corresponding to the given id.
728 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 729 
 
2700 chandransh 730 
    Parameters:
731 
     - id
732 
    """
733 
    pass
734 
 
2690 chandransh 735 
  def processReturn(self, returnOrderId):
736 
    """
737 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 738 
 
2690 chandransh 739 
    Parameters:
740 
     - returnOrderId
741 
    """
742 
    pass
743 
 
3451 chandransh 744 
  def updateWeight(self, orderId, weight):
745 
    """
746 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 747 
 
3451 chandransh 748 
    Parameters:
749 
     - orderId
750 
     - weight
751 
    """
752 
    pass
753 
 
3469 chandransh 754 
  def changeItem(self, orderId, itemId):
755 
    """
756 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
757 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 758 
 
3469 chandransh 759 
    Parameters:
760 
     - orderId
761 
     - itemId
762 
    """
763 
    pass
764 
 
765 
  def shiftToWarehouse(self, orderId, warehouseId):
766 
    """
767 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
768 
 
769 
    Parameters:
770 
     - orderId
771 
     - warehouseId
772 
    """
773 
    pass
774 
 
4647 rajveer 775 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 776 
    """
777 
    Adds the given delay reason to the given order.
3986 chandransh 778 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 779 
    Raises an exception if no order with the given id can be found.
3469 chandransh 780 
 
3553 chandransh 781 
    Parameters:
782 
     - orderId
783 
     - delayReason
3986 chandransh 784 
     - furtherDelay
4647 rajveer 785 
     - delayReasonText
3553 chandransh 786 
    """
787 
    pass
788 
 
3956 chandransh 789 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
790 
    """
791 
    Marks the COD orders with given AWB nos. as having been processed.
792 
    Updates the captured amount for the corresponding payment.
3553 chandransh 793 
 
3956 chandransh 794 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
795 
    1. There is no order corresponding to an AWB number.
796 
    2. The captured amount for a payment exceeds the total payment.
797 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
798 
 
799 
    Parameters:
800 
     - collectedAmountMap
801 
     - xferBy
802 
     - xferTxnId
803 
     - xferDate
804 
    """
805 
    pass
806 
 
4008 mandeep.dh 807 
  def getTransactionsRequiringExtraProcessing(self, category):
808 
    """
4065 mandeep.dh 809 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 810 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 811 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 812 
 
4008 mandeep.dh 813 
    Parameters:
814 
     - category
815 
    """
816 
    pass
817 
 
818 
  def markTransactionAsProcessed(self, transactionId, category):
819 
    """
820 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 821 
    It essentially deletes the transaction id record for a particular
822 
    processing type category (if present) from DB.
823 
    This is currently used by CRM application.
4008 mandeep.dh 824 
 
825 
    Parameters:
826 
     - transactionId
827 
     - category
828 
    """
829 
    pass
830 
 
4018 chandransh 831 
  def getItemWiseRiskyOrdersCount(self, ):
832 
    """
833 
    Returns a map containing the number of risky orders keyed by item id. A risky order
834 
    is defined as one whose shipping date is about to expire.
835 
    """
836 
    pass
4008 mandeep.dh 837 
 
4295 varun.gupt 838 
  def getOrdersForItemIds(self, itemIds):
839 
    """
840 
    Returns a list of all orders which have items with given id
841 
 
842 
    Parameters:
843 
     - itemIds
844 
    """
845 
    pass
846 
 
4247 rajveer 847 
  def markOrderCancellationRequestReceived(self, orderId):
848 
    """
849 
    Mark order as cancellation request received. If customer sends request of cancellation of
850 
    a particular order, this method will be called. It will just change status of the order
851 
    depending on its current status. It also records the previous status, so that we can move
852 
    back to that status if cancellation request is denied.
4018 chandransh 853 
 
4247 rajveer 854 
    Parameters:
855 
     - orderId
856 
    """
857 
    pass
858 
 
859 
  def markOrderCancellationRequestConfirmed(self, orderId):
860 
    """
861 
    If we decide to to cancel order, CRM will call this method to move the status of order to
862 
    cancellation request confirmed. After this OM will be able to cancel the order.
863 
 
864 
    Parameters:
865 
     - orderId
866 
    """
867 
    pass
868 
 
869 
  def markOrderCancellationRequestDenied(self, orderId):
870 
    """
871 
    If we decide to not to cancel order, we will move the order ro previous status.
872 
 
873 
    Parameters:
874 
     - orderId
875 
    """
876 
    pass
877 
 
4258 rajveer 878 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 879 
    """
4258 rajveer 880 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
881 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 882 
 
883 
    Parameters:
4258 rajveer 884 
     - transactionId
4247 rajveer 885 
    """
886 
    pass
887 
 
4259 anupam.sin 888 
  def refundTransaction(self, transactionId, refundedBy, reason):
889 
    """
890 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
891 
    need to be cancelled
4247 rajveer 892 
 
4259 anupam.sin 893 
    Parameters:
894 
     - transactionId
895 
     - refundedBy
896 
     - reason
897 
    """
898 
    pass
899 
 
4324 mandeep.dh 900 
  def updateShipmentAddress(self, orderId, addressId):
901 
    """
902 
    Updates shipment address of an order. Delivery and shipping date estimates
903 
    etc. are also updated here.
904 
 
905 
    Throws TransactionServiceException in case address change is not
906 
    possible due to certain reasons such as new pincode in address is
907 
    not serviceable etc.
908 
 
909 
    Parameters:
910 
     - orderId
911 
     - addressId
912 
    """
913 
    pass
914 
 
4285 rajveer 915 
  def acceptOrdersForItemId(self, itemId, inventory):
916 
    """
917 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
918 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 919 
 
4285 rajveer 920 
    Parameters:
921 
     - itemId
922 
     - inventory
923 
    """
924 
    pass
925 
 
4369 rajveer 926 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 927 
    """
928 
    Parameters:
929 
     - vendorId
930 
     - itemId
931 
     - quantity
932 
     - estimate
4369 rajveer 933 
     - isReminder
4303 rajveer 934 
    """
935 
    pass
4285 rajveer 936 
 
4369 rajveer 937 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 938 
    """
939 
    Parameters:
940 
     - vendorId
941 
     - itemId
942 
     - quantity
943 
     - estimate
4369 rajveer 944 
     - isReminder
4303 rajveer 945 
    """
946 
    pass
947 
 
4369 rajveer 948 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 949 
    """
950 
    Parameters:
951 
     - vendorId
952 
     - itemId
953 
     - quantity
954 
     - estimate
4369 rajveer 955 
     - isReminder
4303 rajveer 956 
    """
957 
    pass
958 
 
4369 rajveer 959 
  def markOrdersAsTimeout(self, vendorId):
960 
    """
961 
    Parameters:
962 
     - vendorId
963 
    """
964 
    pass
4303 rajveer 965 
 
4662 rajveer 966 
  def markOrderAsLostInTransit(self, orderId):
967 
    """
968 
    Mark order as LOST_IN_TRANSIT
969 
 
970 
    Parameters:
971 
     - orderId
972 
    """
973 
    pass
974 
 
4386 anupam.sin 975 
  def getOrderForAwb(self, awb):
976 
    """
977 
    Returns the order corresponding to an AWB number
4369 rajveer 978 
 
4386 anupam.sin 979 
    Parameters:
980 
     - awb
981 
    """
982 
    pass
983 
 
4910 phani.kuma 984 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 985 
    """
4910 phani.kuma 986 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 987 
 
4506 phani.kuma 988 
    Parameters:
989 
     - logistics_provider_id
4910 phani.kuma 990 
     - order_status_list
4506 phani.kuma 991 
    """
992 
    pass
993 
 
4600 varun.gupt 994 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
995 
    """
996 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 997 
 
4600 varun.gupt 998 
    Parameters:
999 
     - vendorId
1000 
     - billingDateFrom
1001 
     - billingDateTo
1002 
    """
1003 
    pass
1004 
 
4607 rajveer 1005 
  def getSlippedSippingDateOrders(self, ):
1006 
    pass
1007 
 
4709 rajveer 1008 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1009 
    """
1010 
    Parameters:
1011 
     - cancelDateFrom
1012 
     - cancelDateTo
1013 
    """
1014 
    pass
1015 
 
4600 varun.gupt 1016 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1017 
    """
1018 
    Parameters:
1019 
     - mapAWBAndAmount
1020 
    """
1021 
    pass
1022 
 
4905 varun.gupt 1023 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1024 
    """
1025 
    Parameters:
1026 
     - settlementDate
1027 
     - paymentGatewayId
4905 varun.gupt 1028 
     - referenceId
4600 varun.gupt 1029 
     - serviceTax
1030 
     - otherCharges
1031 
     - netCollection
1032 
    """
1033 
    pass
1034 
 
1035 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1036 
    """
1037 
    Parameters:
1038 
     - settlementId
1039 
     - settlementDate
1040 
     - transactionDateFrom
1041 
     - transactionDateTo
1042 
     - amount
1043 
    """
1044 
    pass
1045 
 
5189 varun.gupt 1046 
  def getSettlementForReferenceId(self, referenceId, isRefund):
4600 varun.gupt 1047 
    """
1048 
    Parameters:
5189 varun.gupt 1049 
     - referenceId
1050 
     - isRefund
4600 varun.gupt 1051 
    """
1052 
    pass
1053 
 
1054 
  def getEBSSettlementSummaries(self, ):
1055 
    pass
1056 
 
1057 
  def markEBSSettlementUploaded(self, settlementId):
1058 
    """
1059 
    Parameters:
1060 
     - settlementId
1061 
    """
1062 
    pass
1063 
 
1064 
  def getEBSSettlementDate(self, settlementId):
1065 
    """
1066 
    Parameters:
1067 
     - settlementId
1068 
    """
1069 
    pass
1070 
 
4715 varun.gupt 1071 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1072 
    """
1073 
    Parameters:
1074 
     - settlementDateFrom
1075 
     - settlementDateTo
1076 
     - isRefund
1077 
    """
1078 
    pass
4600 varun.gupt 1079 
 
4715 varun.gupt 1080 
  def getReshippedOrderIds(self, orderIds):
1081 
    """
1082 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1083 
 
1084 
    Parameters:
1085 
     - orderIds
1086 
    """
1087 
    pass
1088 
 
4757 mandeep.dh 1089 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
1090 
    """
1091 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
1092 
    the quantities for which the PO is raised.
4715 varun.gupt 1093 
 
4757 mandeep.dh 1094 
    Parameters:
1095 
     - itemIdQuantityMap
1096 
     - purchaseOrderId
1097 
     - warehouseId
1098 
    """
1099 
    pass
1100 
 
4875 varun.gupt 1101 
  def getOrdersWhereVendorNotPaid(self, vendorId):
1102 
    """
1103 
    Parameters:
1104 
     - vendorId
1105 
    """
1106 
    pass
4757 mandeep.dh 1107 
 
5031 varun.gupt 1108 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1109 
    """
1110 
    Parameters:
1111 
     - startDate
1112 
     - endDate
1113 
    """
1114 
    pass
4875 varun.gupt 1115 
 
5067 varun.gupt 1116 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1117 
    """
1118 
    Parameters:
1119 
     - status
1120 
     - startDatetime
1121 
     - endDatetime
1122 
    """
1123 
    pass
5031 varun.gupt 1124 
 
5099 varun.gupt 1125 
  def updateOrderAsPaidToVendor(self, orderId):
1126 
    """
1127 
    Parameters:
1128 
     - orderId
1129 
    """
1130 
    pass
5067 varun.gupt 1131 
 
5099 varun.gupt 1132 
 
3376 rajveer 1133 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1134 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1135 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1136 
 
1137 
  def createTransaction(self, transaction):
1138 
    """
1139 
    Parameters:
1140 
     - transaction
1141 
    """
1142 
    self.send_createTransaction(transaction)
132 ashish 1143 
    return self.recv_createTransaction()
94 ashish 1144 
 
1145 
  def send_createTransaction(self, transaction):
1146 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1147 
    args = createTransaction_args()
1148 
    args.transaction = transaction
1149 
    args.write(self._oprot)
1150 
    self._oprot.writeMessageEnd()
1151 
    self._oprot.trans.flush()
1152 
 
1153 
  def recv_createTransaction(self, ):
1154 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1155 
    if mtype == TMessageType.EXCEPTION:
1156 
      x = TApplicationException()
1157 
      x.read(self._iprot)
1158 
      self._iprot.readMessageEnd()
1159 
      raise x
1160 
    result = createTransaction_result()
1161 
    result.read(self._iprot)
1162 
    self._iprot.readMessageEnd()
3431 rajveer 1163 
    if result.success is not None:
132 ashish 1164 
      return result.success
3431 rajveer 1165 
    if result.ex is not None:
94 ashish 1166 
      raise result.ex
132 ashish 1167 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1168 
 
1169 
  def getTransaction(self, id):
1170 
    """
1171 
    Parameters:
1172 
     - id
1173 
    """
1174 
    self.send_getTransaction(id)
1175 
    return self.recv_getTransaction()
1176 
 
1177 
  def send_getTransaction(self, id):
1178 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1179 
    args = getTransaction_args()
1180 
    args.id = id
1181 
    args.write(self._oprot)
1182 
    self._oprot.writeMessageEnd()
1183 
    self._oprot.trans.flush()
1184 
 
1185 
  def recv_getTransaction(self, ):
1186 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1187 
    if mtype == TMessageType.EXCEPTION:
1188 
      x = TApplicationException()
1189 
      x.read(self._iprot)
1190 
      self._iprot.readMessageEnd()
1191 
      raise x
1192 
    result = getTransaction_result()
1193 
    result.read(self._iprot)
1194 
    self._iprot.readMessageEnd()
3431 rajveer 1195 
    if result.success is not None:
94 ashish 1196 
      return result.success
3431 rajveer 1197 
    if result.ex is not None:
94 ashish 1198 
      raise result.ex
1199 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1200 
 
1201 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1202 
    """
1203 
    Parameters:
1204 
     - customerId
1205 
     - from_date
1206 
     - to_date
1207 
     - status
1208 
    """
1209 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1210 
    return self.recv_getTransactionsForCustomer()
1211 
 
1212 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1213 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1214 
    args = getTransactionsForCustomer_args()
1215 
    args.customerId = customerId
1216 
    args.from_date = from_date
1217 
    args.to_date = to_date
1218 
    args.status = status
1219 
    args.write(self._oprot)
1220 
    self._oprot.writeMessageEnd()
1221 
    self._oprot.trans.flush()
1222 
 
1223 
  def recv_getTransactionsForCustomer(self, ):
1224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1225 
    if mtype == TMessageType.EXCEPTION:
1226 
      x = TApplicationException()
1227 
      x.read(self._iprot)
1228 
      self._iprot.readMessageEnd()
1229 
      raise x
1230 
    result = getTransactionsForCustomer_result()
1231 
    result.read(self._iprot)
1232 
    self._iprot.readMessageEnd()
3431 rajveer 1233 
    if result.success is not None:
94 ashish 1234 
      return result.success
3431 rajveer 1235 
    if result.ex is not None:
94 ashish 1236 
      raise result.ex
1237 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1238 
 
132 ashish 1239 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1240 
    """
1241 
    Parameters:
1242 
     - shoppingCartId
1243 
    """
1244 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1245 
    return self.recv_getTransactionsForShoppingCartId()
1246 
 
1247 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1248 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1249 
    args = getTransactionsForShoppingCartId_args()
1250 
    args.shoppingCartId = shoppingCartId
1251 
    args.write(self._oprot)
1252 
    self._oprot.writeMessageEnd()
1253 
    self._oprot.trans.flush()
1254 
 
1255 
  def recv_getTransactionsForShoppingCartId(self, ):
1256 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1257 
    if mtype == TMessageType.EXCEPTION:
1258 
      x = TApplicationException()
1259 
      x.read(self._iprot)
1260 
      self._iprot.readMessageEnd()
1261 
      raise x
1262 
    result = getTransactionsForShoppingCartId_result()
1263 
    result.read(self._iprot)
1264 
    self._iprot.readMessageEnd()
3431 rajveer 1265 
    if result.success is not None:
132 ashish 1266 
      return result.success
3431 rajveer 1267 
    if result.ex is not None:
132 ashish 1268 
      raise result.ex
1269 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1270 
 
94 ashish 1271 
  def getTransactionStatus(self, transactionId):
1272 
    """
1273 
    Parameters:
1274 
     - transactionId
1275 
    """
1276 
    self.send_getTransactionStatus(transactionId)
1277 
    return self.recv_getTransactionStatus()
1278 
 
1279 
  def send_getTransactionStatus(self, transactionId):
1280 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1281 
    args = getTransactionStatus_args()
1282 
    args.transactionId = transactionId
1283 
    args.write(self._oprot)
1284 
    self._oprot.writeMessageEnd()
1285 
    self._oprot.trans.flush()
1286 
 
1287 
  def recv_getTransactionStatus(self, ):
1288 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1289 
    if mtype == TMessageType.EXCEPTION:
1290 
      x = TApplicationException()
1291 
      x.read(self._iprot)
1292 
      self._iprot.readMessageEnd()
1293 
      raise x
1294 
    result = getTransactionStatus_result()
1295 
    result.read(self._iprot)
1296 
    self._iprot.readMessageEnd()
3431 rajveer 1297 
    if result.success is not None:
94 ashish 1298 
      return result.success
3431 rajveer 1299 
    if result.ex is not None:
94 ashish 1300 
      raise result.ex
1301 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1302 
 
1303 
  def changeTransactionStatus(self, transactionId, status, description):
1304 
    """
1305 
    Parameters:
1306 
     - transactionId
1307 
     - status
1308 
     - description
1309 
    """
1310 
    self.send_changeTransactionStatus(transactionId, status, description)
1311 
    return self.recv_changeTransactionStatus()
1312 
 
1313 
  def send_changeTransactionStatus(self, transactionId, status, description):
1314 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1315 
    args = changeTransactionStatus_args()
1316 
    args.transactionId = transactionId
1317 
    args.status = status
1318 
    args.description = description
1319 
    args.write(self._oprot)
1320 
    self._oprot.writeMessageEnd()
1321 
    self._oprot.trans.flush()
1322 
 
1323 
  def recv_changeTransactionStatus(self, ):
1324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1325 
    if mtype == TMessageType.EXCEPTION:
1326 
      x = TApplicationException()
1327 
      x.read(self._iprot)
1328 
      self._iprot.readMessageEnd()
1329 
      raise x
1330 
    result = changeTransactionStatus_result()
1331 
    result.read(self._iprot)
1332 
    self._iprot.readMessageEnd()
3431 rajveer 1333 
    if result.success is not None:
94 ashish 1334 
      return result.success
3431 rajveer 1335 
    if result.ex is not None:
94 ashish 1336 
      raise result.ex
1337 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1338 
 
1398 varun.gupt 1339 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1340 
    """
1341 
    Parameters:
1342 
     - transactionId
1343 
    """
1398 varun.gupt 1344 
    self.send_enqueueTransactionInfoEmail(transactionId)
1345 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1346 
 
1398 varun.gupt 1347 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1348 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1349 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1350 
    args.transactionId = transactionId
1351 
    args.write(self._oprot)
1352 
    self._oprot.writeMessageEnd()
1353 
    self._oprot.trans.flush()
1354 
 
1398 varun.gupt 1355 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1357 
    if mtype == TMessageType.EXCEPTION:
1358 
      x = TApplicationException()
1359 
      x.read(self._iprot)
1360 
      self._iprot.readMessageEnd()
1361 
      raise x
1398 varun.gupt 1362 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1363 
    result.read(self._iprot)
1364 
    self._iprot.readMessageEnd()
3431 rajveer 1365 
    if result.success is not None:
1382 varun.gupt 1366 
      return result.success
3431 rajveer 1367 
    if result.ex is not None:
1382 varun.gupt 1368 
      raise result.ex
1398 varun.gupt 1369 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1370 
 
4801 anupam.sin 1371 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1372 
    """
1373 
    Parameters:
4801 anupam.sin 1374 
     - statuses
483 rajveer 1375 
     - from_date
1376 
     - to_date
1377 
     - warehouse_id
94 ashish 1378 
    """
4801 anupam.sin 1379 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1380 
    return self.recv_getAllOrders()
94 ashish 1381 
 
4801 anupam.sin 1382 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1383 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1384 
    args = getAllOrders_args()
4801 anupam.sin 1385 
    args.statuses = statuses
483 rajveer 1386 
    args.from_date = from_date
1387 
    args.to_date = to_date
1388 
    args.warehouse_id = warehouse_id
94 ashish 1389 
    args.write(self._oprot)
1390 
    self._oprot.writeMessageEnd()
1391 
    self._oprot.trans.flush()
1392 
 
483 rajveer 1393 
  def recv_getAllOrders(self, ):
94 ashish 1394 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1395 
    if mtype == TMessageType.EXCEPTION:
1396 
      x = TApplicationException()
1397 
      x.read(self._iprot)
1398 
      self._iprot.readMessageEnd()
1399 
      raise x
483 rajveer 1400 
    result = getAllOrders_result()
94 ashish 1401 
    result.read(self._iprot)
1402 
    self._iprot.readMessageEnd()
3431 rajveer 1403 
    if result.success is not None:
94 ashish 1404 
      return result.success
3431 rajveer 1405 
    if result.ex is not None:
94 ashish 1406 
      raise result.ex
483 rajveer 1407 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1408 
 
4133 chandransh 1409 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1410 
    """
1411 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1412 
    Pass the status as null and the limit as 0 to ignore them.
1413 
 
1414 
    Parameters:
1415 
     - statuses
1416 
     - offset
1417 
     - limit
1418 
     - warehouse_id
1419 
    """
1420 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1421 
    return self.recv_getOrdersInBatch()
1422 
 
1423 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1424 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1425 
    args = getOrdersInBatch_args()
1426 
    args.statuses = statuses
1427 
    args.offset = offset
1428 
    args.limit = limit
1429 
    args.warehouse_id = warehouse_id
1430 
    args.write(self._oprot)
1431 
    self._oprot.writeMessageEnd()
1432 
    self._oprot.trans.flush()
1433 
 
1434 
  def recv_getOrdersInBatch(self, ):
1435 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1436 
    if mtype == TMessageType.EXCEPTION:
1437 
      x = TApplicationException()
1438 
      x.read(self._iprot)
1439 
      self._iprot.readMessageEnd()
1440 
      raise x
1441 
    result = getOrdersInBatch_result()
1442 
    result.read(self._iprot)
1443 
    self._iprot.readMessageEnd()
1444 
    if result.success is not None:
1445 
      return result.success
1446 
    if result.ex is not None:
1447 
      raise result.ex
1448 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1449 
 
1450 
  def getOrderCount(self, statuses, warehouseId):
1451 
    """
1452 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1453 
 
1454 
    Parameters:
1455 
     - statuses
1456 
     - warehouseId
1457 
    """
1458 
    self.send_getOrderCount(statuses, warehouseId)
1459 
    return self.recv_getOrderCount()
1460 
 
1461 
  def send_getOrderCount(self, statuses, warehouseId):
1462 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1463 
    args = getOrderCount_args()
1464 
    args.statuses = statuses
1465 
    args.warehouseId = warehouseId
1466 
    args.write(self._oprot)
1467 
    self._oprot.writeMessageEnd()
1468 
    self._oprot.trans.flush()
1469 
 
1470 
  def recv_getOrderCount(self, ):
1471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1472 
    if mtype == TMessageType.EXCEPTION:
1473 
      x = TApplicationException()
1474 
      x.read(self._iprot)
1475 
      self._iprot.readMessageEnd()
1476 
      raise x
1477 
    result = getOrderCount_result()
1478 
    result.read(self._iprot)
1479 
    self._iprot.readMessageEnd()
1480 
    if result.success is not None:
1481 
      return result.success
1482 
    if result.ex is not None:
1483 
      raise result.ex
1484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1485 
 
999 varun.gupt 1486 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1487 
    """
1132 chandransh 1488 
    Returns orders within a range of their billing dates
3431 rajveer 1489 
 
999 varun.gupt 1490 
    Parameters:
1491 
     - status
1492 
     - start_billing_date
1493 
     - end_billing_date
1494 
     - warehouse_id
1495 
    """
1496 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1497 
    return self.recv_getOrdersByBillingDate()
1498 
 
1499 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1500 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1501 
    args = getOrdersByBillingDate_args()
1502 
    args.status = status
1503 
    args.start_billing_date = start_billing_date
1504 
    args.end_billing_date = end_billing_date
1505 
    args.warehouse_id = warehouse_id
1506 
    args.write(self._oprot)
1507 
    self._oprot.writeMessageEnd()
1508 
    self._oprot.trans.flush()
1509 
 
1510 
  def recv_getOrdersByBillingDate(self, ):
1511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1512 
    if mtype == TMessageType.EXCEPTION:
1513 
      x = TApplicationException()
1514 
      x.read(self._iprot)
1515 
      self._iprot.readMessageEnd()
1516 
      raise x
1517 
    result = getOrdersByBillingDate_result()
1518 
    result.read(self._iprot)
1519 
    self._iprot.readMessageEnd()
3431 rajveer 1520 
    if result.success is not None:
999 varun.gupt 1521 
      return result.success
3431 rajveer 1522 
    if result.ex is not None:
999 varun.gupt 1523 
      raise result.ex
1524 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1525 
 
3451 chandransh 1526 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1527 
    """
1528 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1529 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1530 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1531 
 
3427 chandransh 1532 
    Parameters:
1533 
     - fromShippingDate
1534 
     - toShippingDate
1535 
     - providerId
1536 
     - warehouseId
3451 chandransh 1537 
     - cod
3427 chandransh 1538 
    """
3451 chandransh 1539 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1540 
    return self.recv_getOrdersByShippingDate()
1541 
 
3451 chandransh 1542 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1543 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1544 
    args = getOrdersByShippingDate_args()
1545 
    args.fromShippingDate = fromShippingDate
1546 
    args.toShippingDate = toShippingDate
1547 
    args.providerId = providerId
1548 
    args.warehouseId = warehouseId
3451 chandransh 1549 
    args.cod = cod
3427 chandransh 1550 
    args.write(self._oprot)
1551 
    self._oprot.writeMessageEnd()
1552 
    self._oprot.trans.flush()
1553 
 
1554 
  def recv_getOrdersByShippingDate(self, ):
1555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1556 
    if mtype == TMessageType.EXCEPTION:
1557 
      x = TApplicationException()
1558 
      x.read(self._iprot)
1559 
      self._iprot.readMessageEnd()
1560 
      raise x
1561 
    result = getOrdersByShippingDate_result()
1562 
    result.read(self._iprot)
1563 
    self._iprot.readMessageEnd()
3431 rajveer 1564 
    if result.success is not None:
3427 chandransh 1565 
      return result.success
3431 rajveer 1566 
    if result.ex is not None:
3427 chandransh 1567 
      raise result.ex
1568 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1569 
 
1382 varun.gupt 1570 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1571 
    """
1572 
    Returns order ids for orders which can be returned
3431 rajveer 1573 
 
1382 varun.gupt 1574 
    Parameters:
1575 
     - customer_id
1576 
     - limit
1577 
    """
1578 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1579 
    return self.recv_getReturnableOrdersForCustomer()
1580 
 
1581 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1582 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1583 
    args = getReturnableOrdersForCustomer_args()
1584 
    args.customer_id = customer_id
1585 
    args.limit = limit
1586 
    args.write(self._oprot)
1587 
    self._oprot.writeMessageEnd()
1588 
    self._oprot.trans.flush()
1589 
 
1590 
  def recv_getReturnableOrdersForCustomer(self, ):
1591 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1592 
    if mtype == TMessageType.EXCEPTION:
1593 
      x = TApplicationException()
1594 
      x.read(self._iprot)
1595 
      self._iprot.readMessageEnd()
1596 
      raise x
1597 
    result = getReturnableOrdersForCustomer_result()
1598 
    result.read(self._iprot)
1599 
    self._iprot.readMessageEnd()
3431 rajveer 1600 
    if result.success is not None:
1382 varun.gupt 1601 
      return result.success
3431 rajveer 1602 
    if result.ex is not None:
1382 varun.gupt 1603 
      raise result.ex
1604 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1605 
 
1606 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1607 
    """
1608 
    Returns order ids for orders which can be cancelled
3431 rajveer 1609 
 
1382 varun.gupt 1610 
    Parameters:
1611 
     - customer_id
1612 
     - limit
1613 
    """
1614 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1615 
    return self.recv_getCancellableOrdersForCustomer()
1616 
 
1617 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1618 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1619 
    args = getCancellableOrdersForCustomer_args()
1620 
    args.customer_id = customer_id
1621 
    args.limit = limit
1622 
    args.write(self._oprot)
1623 
    self._oprot.writeMessageEnd()
1624 
    self._oprot.trans.flush()
1625 
 
1626 
  def recv_getCancellableOrdersForCustomer(self, ):
1627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1628 
    if mtype == TMessageType.EXCEPTION:
1629 
      x = TApplicationException()
1630 
      x.read(self._iprot)
1631 
      self._iprot.readMessageEnd()
1632 
      raise x
1633 
    result = getCancellableOrdersForCustomer_result()
1634 
    result.read(self._iprot)
1635 
    self._iprot.readMessageEnd()
3431 rajveer 1636 
    if result.success is not None:
1382 varun.gupt 1637 
      return result.success
3431 rajveer 1638 
    if result.ex is not None:
1382 varun.gupt 1639 
      raise result.ex
1640 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1641 
 
483 rajveer 1642 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1643 
    """
1644 
    Parameters:
483 rajveer 1645 
     - orderId
1646 
     - status
1647 
     - description
94 ashish 1648 
    """
483 rajveer 1649 
    self.send_changeOrderStatus(orderId, status, description)
1650 
    return self.recv_changeOrderStatus()
94 ashish 1651 
 
483 rajveer 1652 
  def send_changeOrderStatus(self, orderId, status, description):
1653 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1654 
    args = changeOrderStatus_args()
1655 
    args.orderId = orderId
1656 
    args.status = status
1657 
    args.description = description
94 ashish 1658 
    args.write(self._oprot)
1659 
    self._oprot.writeMessageEnd()
1660 
    self._oprot.trans.flush()
1661 
 
483 rajveer 1662 
  def recv_changeOrderStatus(self, ):
94 ashish 1663 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1664 
    if mtype == TMessageType.EXCEPTION:
1665 
      x = TApplicationException()
1666 
      x.read(self._iprot)
1667 
      self._iprot.readMessageEnd()
1668 
      raise x
483 rajveer 1669 
    result = changeOrderStatus_result()
94 ashish 1670 
    result.read(self._iprot)
1671 
    self._iprot.readMessageEnd()
3431 rajveer 1672 
    if result.success is not None:
94 ashish 1673 
      return result.success
3431 rajveer 1674 
    if result.ex is not None:
94 ashish 1675 
      raise result.ex
483 rajveer 1676 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1677 
 
1528 ankur.sing 1678 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1679 
    """
1528 ankur.sing 1680 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1681 
    only user who owns the transaction can view its order details.
3431 rajveer 1682 
 
94 ashish 1683 
    Parameters:
1684 
     - transactionId
1528 ankur.sing 1685 
     - customerId
94 ashish 1686 
    """
1528 ankur.sing 1687 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1688 
    return self.recv_getOrdersForTransaction()
94 ashish 1689 
 
1528 ankur.sing 1690 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1691 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1692 
    args = getOrdersForTransaction_args()
94 ashish 1693 
    args.transactionId = transactionId
1528 ankur.sing 1694 
    args.customerId = customerId
94 ashish 1695 
    args.write(self._oprot)
1696 
    self._oprot.writeMessageEnd()
1697 
    self._oprot.trans.flush()
1698 
 
483 rajveer 1699 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1701 
    if mtype == TMessageType.EXCEPTION:
1702 
      x = TApplicationException()
1703 
      x.read(self._iprot)
1704 
      self._iprot.readMessageEnd()
1705 
      raise x
483 rajveer 1706 
    result = getOrdersForTransaction_result()
94 ashish 1707 
    result.read(self._iprot)
1708 
    self._iprot.readMessageEnd()
3431 rajveer 1709 
    if result.success is not None:
94 ashish 1710 
      return result.success
3431 rajveer 1711 
    if result.ex is not None:
94 ashish 1712 
      raise result.ex
483 rajveer 1713 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1714 
 
3014 chandransh 1715 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1716 
    """
3014 chandransh 1717 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1718 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1719 
 
94 ashish 1720 
    Parameters:
483 rajveer 1721 
     - customerId
1722 
     - from_date
1723 
     - to_date
3014 chandransh 1724 
     - statuses
94 ashish 1725 
    """
3014 chandransh 1726 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1727 
    return self.recv_getOrdersForCustomer()
94 ashish 1728 
 
3014 chandransh 1729 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1730 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1731 
    args = getOrdersForCustomer_args()
1732 
    args.customerId = customerId
1733 
    args.from_date = from_date
1734 
    args.to_date = to_date
3014 chandransh 1735 
    args.statuses = statuses
94 ashish 1736 
    args.write(self._oprot)
1737 
    self._oprot.writeMessageEnd()
1738 
    self._oprot.trans.flush()
1739 
 
483 rajveer 1740 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1742 
    if mtype == TMessageType.EXCEPTION:
1743 
      x = TApplicationException()
1744 
      x.read(self._iprot)
1745 
      self._iprot.readMessageEnd()
1746 
      raise x
483 rajveer 1747 
    result = getOrdersForCustomer_result()
94 ashish 1748 
    result.read(self._iprot)
1749 
    self._iprot.readMessageEnd()
3431 rajveer 1750 
    if result.success is not None:
94 ashish 1751 
      return result.success
3431 rajveer 1752 
    if result.ex is not None:
94 ashish 1753 
      raise result.ex
483 rajveer 1754 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1755 
 
483 rajveer 1756 
  def createOrder(self, order):
94 ashish 1757 
    """
1758 
    Parameters:
483 rajveer 1759 
     - order
94 ashish 1760 
    """
483 rajveer 1761 
    self.send_createOrder(order)
1762 
    return self.recv_createOrder()
94 ashish 1763 
 
483 rajveer 1764 
  def send_createOrder(self, order):
1765 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1766 
    args = createOrder_args()
1767 
    args.order = order
94 ashish 1768 
    args.write(self._oprot)
1769 
    self._oprot.writeMessageEnd()
1770 
    self._oprot.trans.flush()
1771 
 
483 rajveer 1772 
  def recv_createOrder(self, ):
94 ashish 1773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1774 
    if mtype == TMessageType.EXCEPTION:
1775 
      x = TApplicationException()
1776 
      x.read(self._iprot)
1777 
      self._iprot.readMessageEnd()
1778 
      raise x
483 rajveer 1779 
    result = createOrder_result()
94 ashish 1780 
    result.read(self._iprot)
1781 
    self._iprot.readMessageEnd()
3431 rajveer 1782 
    if result.success is not None:
94 ashish 1783 
      return result.success
3431 rajveer 1784 
    if result.ex is not None:
94 ashish 1785 
      raise result.ex
483 rajveer 1786 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1787 
 
483 rajveer 1788 
  def getOrder(self, id):
94 ashish 1789 
    """
1790 
    Parameters:
483 rajveer 1791 
     - id
94 ashish 1792 
    """
483 rajveer 1793 
    self.send_getOrder(id)
1794 
    return self.recv_getOrder()
94 ashish 1795 
 
483 rajveer 1796 
  def send_getOrder(self, id):
1797 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1798 
    args = getOrder_args()
1799 
    args.id = id
94 ashish 1800 
    args.write(self._oprot)
1801 
    self._oprot.writeMessageEnd()
1802 
    self._oprot.trans.flush()
1803 
 
483 rajveer 1804 
  def recv_getOrder(self, ):
94 ashish 1805 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1806 
    if mtype == TMessageType.EXCEPTION:
1807 
      x = TApplicationException()
1808 
      x.read(self._iprot)
1809 
      self._iprot.readMessageEnd()
1810 
      raise x
483 rajveer 1811 
    result = getOrder_result()
94 ashish 1812 
    result.read(self._iprot)
1813 
    self._iprot.readMessageEnd()
3431 rajveer 1814 
    if result.success is not None:
94 ashish 1815 
      return result.success
3431 rajveer 1816 
    if result.ex is not None:
94 ashish 1817 
      raise result.ex
483 rajveer 1818 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1819 
 
483 rajveer 1820 
  def getLineItemsForOrder(self, orderId):
94 ashish 1821 
    """
1822 
    Parameters:
483 rajveer 1823 
     - orderId
94 ashish 1824 
    """
483 rajveer 1825 
    self.send_getLineItemsForOrder(orderId)
1826 
    return self.recv_getLineItemsForOrder()
94 ashish 1827 
 
483 rajveer 1828 
  def send_getLineItemsForOrder(self, orderId):
1829 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1830 
    args = getLineItemsForOrder_args()
1831 
    args.orderId = orderId
94 ashish 1832 
    args.write(self._oprot)
1833 
    self._oprot.writeMessageEnd()
1834 
    self._oprot.trans.flush()
1835 
 
483 rajveer 1836 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1837 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1838 
    if mtype == TMessageType.EXCEPTION:
1839 
      x = TApplicationException()
1840 
      x.read(self._iprot)
1841 
      self._iprot.readMessageEnd()
1842 
      raise x
483 rajveer 1843 
    result = getLineItemsForOrder_result()
94 ashish 1844 
    result.read(self._iprot)
1845 
    self._iprot.readMessageEnd()
3431 rajveer 1846 
    if result.success is not None:
94 ashish 1847 
      return result.success
3431 rajveer 1848 
    if result.ex is not None:
94 ashish 1849 
      raise result.ex
483 rajveer 1850 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1851 
 
4999 phani.kuma 1852 
  def getOrderList(self, order_ids):
1853 
    """
1854 
    Parameters:
1855 
     - order_ids
1856 
    """
1857 
    self.send_getOrderList(order_ids)
1858 
    return self.recv_getOrderList()
1859 
 
1860 
  def send_getOrderList(self, order_ids):
1861 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
1862 
    args = getOrderList_args()
1863 
    args.order_ids = order_ids
1864 
    args.write(self._oprot)
1865 
    self._oprot.writeMessageEnd()
1866 
    self._oprot.trans.flush()
1867 
 
1868 
  def recv_getOrderList(self, ):
1869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1870 
    if mtype == TMessageType.EXCEPTION:
1871 
      x = TApplicationException()
1872 
      x.read(self._iprot)
1873 
      self._iprot.readMessageEnd()
1874 
      raise x
1875 
    result = getOrderList_result()
1876 
    result.read(self._iprot)
1877 
    self._iprot.readMessageEnd()
1878 
    if result.success is not None:
1879 
      return result.success
1880 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
1881 
 
1528 ankur.sing 1882 
  def getOrderForCustomer(self, orderId, customerId):
1883 
    """
1884 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1885 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1886 
 
1528 ankur.sing 1887 
    Parameters:
1888 
     - orderId
1889 
     - customerId
1890 
    """
1891 
    self.send_getOrderForCustomer(orderId, customerId)
1892 
    return self.recv_getOrderForCustomer()
1893 
 
1894 
  def send_getOrderForCustomer(self, orderId, customerId):
1895 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1896 
    args = getOrderForCustomer_args()
1897 
    args.orderId = orderId
1898 
    args.customerId = customerId
1899 
    args.write(self._oprot)
1900 
    self._oprot.writeMessageEnd()
1901 
    self._oprot.trans.flush()
1902 
 
1903 
  def recv_getOrderForCustomer(self, ):
1904 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1905 
    if mtype == TMessageType.EXCEPTION:
1906 
      x = TApplicationException()
1907 
      x.read(self._iprot)
1908 
      self._iprot.readMessageEnd()
1909 
      raise x
1910 
    result = getOrderForCustomer_result()
1911 
    result.read(self._iprot)
1912 
    self._iprot.readMessageEnd()
3431 rajveer 1913 
    if result.success is not None:
1528 ankur.sing 1914 
      return result.success
3431 rajveer 1915 
    if result.ex is not None:
1528 ankur.sing 1916 
      raise result.ex
1917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1918 
 
4444 rajveer 1919 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1920 
    """
1921 
    Parameters:
4394 rajveer 1922 
     - type
4444 rajveer 1923 
     - warehouseId
4394 rajveer 1924 
     - status
1925 
     - timestamp
3064 chandransh 1926 
    """
4444 rajveer 1927 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1928 
    return self.recv_getAlerts()
1929 
 
4444 rajveer 1930 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1931 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1932 
    args = getAlerts_args()
4394 rajveer 1933 
    args.type = type
4444 rajveer 1934 
    args.warehouseId = warehouseId
4394 rajveer 1935 
    args.status = status
1936 
    args.timestamp = timestamp
3064 chandransh 1937 
    args.write(self._oprot)
1938 
    self._oprot.writeMessageEnd()
1939 
    self._oprot.trans.flush()
1940 
 
1941 
  def recv_getAlerts(self, ):
1942 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1943 
    if mtype == TMessageType.EXCEPTION:
1944 
      x = TApplicationException()
1945 
      x.read(self._iprot)
1946 
      self._iprot.readMessageEnd()
1947 
      raise x
1948 
    result = getAlerts_result()
1949 
    result.read(self._iprot)
1950 
    self._iprot.readMessageEnd()
3431 rajveer 1951 
    if result.success is not None:
3064 chandransh 1952 
      return result.success
1953 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1954 
 
4444 rajveer 1955 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1956 
    """
1957 
    Parameters:
1958 
     - type
4444 rajveer 1959 
     - warehouseId
4394 rajveer 1960 
     - description
3064 chandransh 1961 
    """
4444 rajveer 1962 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1963 
    self.recv_addAlert()
3064 chandransh 1964 
 
4444 rajveer 1965 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1966 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1967 
    args = addAlert_args()
3064 chandransh 1968 
    args.type = type
4444 rajveer 1969 
    args.warehouseId = warehouseId
4394 rajveer 1970 
    args.description = description
3064 chandransh 1971 
    args.write(self._oprot)
1972 
    self._oprot.writeMessageEnd()
1973 
    self._oprot.trans.flush()
1974 
 
4394 rajveer 1975 
  def recv_addAlert(self, ):
3064 chandransh 1976 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1977 
    if mtype == TMessageType.EXCEPTION:
1978 
      x = TApplicationException()
1979 
      x.read(self._iprot)
1980 
      self._iprot.readMessageEnd()
1981 
      raise x
4394 rajveer 1982 
    result = addAlert_result()
3064 chandransh 1983 
    result.read(self._iprot)
1984 
    self._iprot.readMessageEnd()
1985 
    return
1986 
 
4444 rajveer 1987 
  def markAlertsAsSeen(self, warehouseId):
1988 
    """
1989 
    Parameters:
1990 
     - warehouseId
1991 
    """
1992 
    self.send_markAlertsAsSeen(warehouseId)
1993 
    self.recv_markAlertsAsSeen()
1994 
 
1995 
  def send_markAlertsAsSeen(self, warehouseId):
1996 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
1997 
    args = markAlertsAsSeen_args()
1998 
    args.warehouseId = warehouseId
1999 
    args.write(self._oprot)
2000 
    self._oprot.writeMessageEnd()
2001 
    self._oprot.trans.flush()
2002 
 
2003 
  def recv_markAlertsAsSeen(self, ):
2004 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2005 
    if mtype == TMessageType.EXCEPTION:
2006 
      x = TApplicationException()
2007 
      x.read(self._iprot)
2008 
      self._iprot.readMessageEnd()
2009 
      raise x
2010 
    result = markAlertsAsSeen_result()
2011 
    result.read(self._iprot)
2012 
    self._iprot.readMessageEnd()
2013 
    return
2014 
 
3064 chandransh 2015 
  def getValidOrderCount(self, ):
2016 
    """
2017 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2018 
    """
2019 
    self.send_getValidOrderCount()
2020 
    return self.recv_getValidOrderCount()
2021 
 
2022 
  def send_getValidOrderCount(self, ):
2023 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2024 
    args = getValidOrderCount_args()
2025 
    args.write(self._oprot)
2026 
    self._oprot.writeMessageEnd()
2027 
    self._oprot.trans.flush()
2028 
 
2029 
  def recv_getValidOrderCount(self, ):
2030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2031 
    if mtype == TMessageType.EXCEPTION:
2032 
      x = TApplicationException()
2033 
      x.read(self._iprot)
2034 
      self._iprot.readMessageEnd()
2035 
      raise x
2036 
    result = getValidOrderCount_result()
2037 
    result.read(self._iprot)
2038 
    self._iprot.readMessageEnd()
3431 rajveer 2039 
    if result.success is not None:
3064 chandransh 2040 
      return result.success
2041 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2042 
 
2043 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2044 
    """
2045 
    Returns the number of distinct customers who have done successful transactions
2046 
    """
2047 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2048 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2049 
 
2050 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2051 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2052 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2053 
    args.write(self._oprot)
2054 
    self._oprot.writeMessageEnd()
2055 
    self._oprot.trans.flush()
2056 
 
2057 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2058 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2059 
    if mtype == TMessageType.EXCEPTION:
2060 
      x = TApplicationException()
2061 
      x.read(self._iprot)
2062 
      self._iprot.readMessageEnd()
2063 
      raise x
2064 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2065 
    result.read(self._iprot)
2066 
    self._iprot.readMessageEnd()
3431 rajveer 2067 
    if result.success is not None:
3064 chandransh 2068 
      return result.success
2069 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2070 
 
2071 
  def getValidOrdersAmountRange(self, ):
2072 
    """
2073 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2074 
    List contains two values, first minimum amount and second maximum amount.
2075 
    """
2076 
    self.send_getValidOrdersAmountRange()
2077 
    return self.recv_getValidOrdersAmountRange()
2078 
 
2079 
  def send_getValidOrdersAmountRange(self, ):
2080 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2081 
    args = getValidOrdersAmountRange_args()
2082 
    args.write(self._oprot)
2083 
    self._oprot.writeMessageEnd()
2084 
    self._oprot.trans.flush()
2085 
 
2086 
  def recv_getValidOrdersAmountRange(self, ):
2087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2088 
    if mtype == TMessageType.EXCEPTION:
2089 
      x = TApplicationException()
2090 
      x.read(self._iprot)
2091 
      self._iprot.readMessageEnd()
2092 
      raise x
2093 
    result = getValidOrdersAmountRange_result()
2094 
    result.read(self._iprot)
2095 
    self._iprot.readMessageEnd()
3431 rajveer 2096 
    if result.success is not None:
3064 chandransh 2097 
      return result.success
2098 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2099 
 
2100 
  def getValidOrders(self, limit):
2101 
    """
2102 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2103 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2104 
 
3064 chandransh 2105 
    Parameters:
2106 
     - limit
2107 
    """
2108 
    self.send_getValidOrders(limit)
2109 
    return self.recv_getValidOrders()
2110 
 
2111 
  def send_getValidOrders(self, limit):
2112 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2113 
    args = getValidOrders_args()
2114 
    args.limit = limit
2115 
    args.write(self._oprot)
2116 
    self._oprot.writeMessageEnd()
2117 
    self._oprot.trans.flush()
2118 
 
2119 
  def recv_getValidOrders(self, ):
2120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2121 
    if mtype == TMessageType.EXCEPTION:
2122 
      x = TApplicationException()
2123 
      x.read(self._iprot)
2124 
      self._iprot.readMessageEnd()
2125 
      raise x
2126 
    result = getValidOrders_result()
2127 
    result.read(self._iprot)
2128 
    self._iprot.readMessageEnd()
3431 rajveer 2129 
    if result.success is not None:
3064 chandransh 2130 
      return result.success
2131 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2132 
 
1220 chandransh 2133 
  def batchOrders(self, warehouseId):
2134 
    """
2135 
    Create a batch of all the pending orders for the given warehouse.
2136 
    The returned list is orderd by created_timestamp.
2137 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2138 
 
1220 chandransh 2139 
    Parameters:
2140 
     - warehouseId
2141 
    """
2142 
    self.send_batchOrders(warehouseId)
2143 
    return self.recv_batchOrders()
2144 
 
2145 
  def send_batchOrders(self, warehouseId):
2146 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2147 
    args = batchOrders_args()
2148 
    args.warehouseId = warehouseId
2149 
    args.write(self._oprot)
2150 
    self._oprot.writeMessageEnd()
2151 
    self._oprot.trans.flush()
2152 
 
2153 
  def recv_batchOrders(self, ):
2154 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2155 
    if mtype == TMessageType.EXCEPTION:
2156 
      x = TApplicationException()
2157 
      x.read(self._iprot)
2158 
      self._iprot.readMessageEnd()
2159 
      raise x
2160 
    result = batchOrders_result()
2161 
    result.read(self._iprot)
2162 
    self._iprot.readMessageEnd()
3431 rajveer 2163 
    if result.success is not None:
1220 chandransh 2164 
      return result.success
3431 rajveer 2165 
    if result.ex is not None:
1220 chandransh 2166 
      raise result.ex
2167 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2168 
 
1208 chandransh 2169 
  def markOrderAsOutOfStock(self, orderId):
2170 
    """
2171 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2172 
 
1208 chandransh 2173 
    Parameters:
2174 
     - orderId
2175 
    """
2176 
    self.send_markOrderAsOutOfStock(orderId)
2177 
    return self.recv_markOrderAsOutOfStock()
2178 
 
2179 
  def send_markOrderAsOutOfStock(self, orderId):
2180 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2181 
    args = markOrderAsOutOfStock_args()
2182 
    args.orderId = orderId
2183 
    args.write(self._oprot)
2184 
    self._oprot.writeMessageEnd()
2185 
    self._oprot.trans.flush()
2186 
 
2187 
  def recv_markOrderAsOutOfStock(self, ):
2188 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2189 
    if mtype == TMessageType.EXCEPTION:
2190 
      x = TApplicationException()
2191 
      x.read(self._iprot)
2192 
      self._iprot.readMessageEnd()
2193 
      raise x
2194 
    result = markOrderAsOutOfStock_result()
2195 
    result.read(self._iprot)
2196 
    self._iprot.readMessageEnd()
3431 rajveer 2197 
    if result.success is not None:
1208 chandransh 2198 
      return result.success
3431 rajveer 2199 
    if result.ex is not None:
1208 chandransh 2200 
      raise result.ex
2201 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2202 
 
3064 chandransh 2203 
  def verifyOrder(self, orderId):
759 chandransh 2204 
    """
3064 chandransh 2205 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2206 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2207 
    used for all other orders as well.
2208 
    Throws an exception if no such order exists.
3431 rajveer 2209 
 
759 chandransh 2210 
    Parameters:
3064 chandransh 2211 
     - orderId
759 chandransh 2212 
    """
3064 chandransh 2213 
    self.send_verifyOrder(orderId)
2214 
    return self.recv_verifyOrder()
759 chandransh 2215 
 
3064 chandransh 2216 
  def send_verifyOrder(self, orderId):
2217 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2218 
    args = verifyOrder_args()
2219 
    args.orderId = orderId
759 chandransh 2220 
    args.write(self._oprot)
2221 
    self._oprot.writeMessageEnd()
2222 
    self._oprot.trans.flush()
2223 
 
3064 chandransh 2224 
  def recv_verifyOrder(self, ):
759 chandransh 2225 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2226 
    if mtype == TMessageType.EXCEPTION:
2227 
      x = TApplicationException()
2228 
      x.read(self._iprot)
2229 
      self._iprot.readMessageEnd()
2230 
      raise x
3064 chandransh 2231 
    result = verifyOrder_result()
759 chandransh 2232 
    result.read(self._iprot)
2233 
    self._iprot.readMessageEnd()
3431 rajveer 2234 
    if result.success is not None:
759 chandransh 2235 
      return result.success
3431 rajveer 2236 
    if result.ex is not None:
759 chandransh 2237 
      raise result.ex
3064 chandransh 2238 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2239 
 
3064 chandransh 2240 
  def acceptOrder(self, orderId):
1113 chandransh 2241 
    """
3064 chandransh 2242 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2243 
    given order is not a COD order, it also captures the payment if the same has
2244 
    not been captured.
2245 
    Throws an exception if no such order exists.
3431 rajveer 2246 
 
1113 chandransh 2247 
    Parameters:
3064 chandransh 2248 
     - orderId
1113 chandransh 2249 
    """
3064 chandransh 2250 
    self.send_acceptOrder(orderId)
2251 
    return self.recv_acceptOrder()
1113 chandransh 2252 
 
3064 chandransh 2253 
  def send_acceptOrder(self, orderId):
2254 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2255 
    args = acceptOrder_args()
2256 
    args.orderId = orderId
1113 chandransh 2257 
    args.write(self._oprot)
2258 
    self._oprot.writeMessageEnd()
2259 
    self._oprot.trans.flush()
2260 
 
3064 chandransh 2261 
  def recv_acceptOrder(self, ):
1113 chandransh 2262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2263 
    if mtype == TMessageType.EXCEPTION:
2264 
      x = TApplicationException()
2265 
      x.read(self._iprot)
2266 
      self._iprot.readMessageEnd()
2267 
      raise x
3064 chandransh 2268 
    result = acceptOrder_result()
1113 chandransh 2269 
    result.read(self._iprot)
2270 
    self._iprot.readMessageEnd()
3431 rajveer 2271 
    if result.success is not None:
1113 chandransh 2272 
      return result.success
3431 rajveer 2273 
    if result.ex is not None:
1113 chandransh 2274 
      raise result.ex
3064 chandransh 2275 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2276 
 
5110 mandeep.dh 2277 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2278 
    """
3064 chandransh 2279 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2280 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2281 
    the IMEI no. if a -1 is supplied.
2282 
    Also, it generates an invoice number for the order, marks the order as
2283 
    BILLED and sets the billing timestamp.
2284 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2285 
 
1135 chandransh 2286 
    Parameters:
3064 chandransh 2287 
     - orderId
2288 
     - invoice_number
4658 mandeep.dh 2289 
     - serialNumber
4283 anupam.sin 2290 
     - itemNumber
3064 chandransh 2291 
     - billed_by
4264 rajveer 2292 
     - jacketNumber
4283 anupam.sin 2293 
     - billingType
5110 mandeep.dh 2294 
     - fulfilmentWarehouseId
4763 rajveer 2295 
     - authorize
1135 chandransh 2296 
    """
5110 mandeep.dh 2297 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2298 
    return self.recv_addBillingDetails()
1135 chandransh 2299 
 
5110 mandeep.dh 2300 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2301 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2302 
    args = addBillingDetails_args()
2303 
    args.orderId = orderId
2304 
    args.invoice_number = invoice_number
4658 mandeep.dh 2305 
    args.serialNumber = serialNumber
4283 anupam.sin 2306 
    args.itemNumber = itemNumber
3064 chandransh 2307 
    args.billed_by = billed_by
4264 rajveer 2308 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2309 
    args.billingType = billingType
5110 mandeep.dh 2310 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2311 
    args.authorize = authorize
1135 chandransh 2312 
    args.write(self._oprot)
2313 
    self._oprot.writeMessageEnd()
2314 
    self._oprot.trans.flush()
2315 
 
3064 chandransh 2316 
  def recv_addBillingDetails(self, ):
1135 chandransh 2317 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2318 
    if mtype == TMessageType.EXCEPTION:
2319 
      x = TApplicationException()
2320 
      x.read(self._iprot)
2321 
      self._iprot.readMessageEnd()
2322 
      raise x
3064 chandransh 2323 
    result = addBillingDetails_result()
1135 chandransh 2324 
    result.read(self._iprot)
2325 
    self._iprot.readMessageEnd()
3431 rajveer 2326 
    if result.success is not None:
3064 chandransh 2327 
      return result.success
3431 rajveer 2328 
    if result.ex is not None:
1135 chandransh 2329 
      raise result.ex
3064 chandransh 2330 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2331 
 
4763 rajveer 2332 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2333 
    """
2334 
    Add the invoice number to the order.
2335 
 
2336 
    Parameters:
2337 
     - orderId
2338 
     - invoiceNumber
4763 rajveer 2339 
     - color
4579 rajveer 2340 
    """
4763 rajveer 2341 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2342 
    self.recv_addInvoiceNumber()
2343 
 
4763 rajveer 2344 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2345 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2346 
    args = addInvoiceNumber_args()
2347 
    args.orderId = orderId
2348 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2349 
    args.color = color
4579 rajveer 2350 
    args.write(self._oprot)
2351 
    self._oprot.writeMessageEnd()
2352 
    self._oprot.trans.flush()
2353 
 
2354 
  def recv_addInvoiceNumber(self, ):
2355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2356 
    if mtype == TMessageType.EXCEPTION:
2357 
      x = TApplicationException()
2358 
      x.read(self._iprot)
2359 
      self._iprot.readMessageEnd()
2360 
      raise x
2361 
    result = addInvoiceNumber_result()
2362 
    result.read(self._iprot)
2363 
    self._iprot.readMessageEnd()
2364 
    if result.ex is not None:
2365 
      raise result.ex
2366 
    return
2367 
 
4910 phani.kuma 2368 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2369 
    """
3064 chandransh 2370 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2371 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2372 
 
1408 ankur.sing 2373 
    Parameters:
3064 chandransh 2374 
     - warehouseId
1408 ankur.sing 2375 
     - providerId
3064 chandransh 2376 
     - cod
4910 phani.kuma 2377 
     - orderIds
1408 ankur.sing 2378 
    """
4910 phani.kuma 2379 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2380 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2381 
 
4910 phani.kuma 2382 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2383 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2384 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2385 
    args.warehouseId = warehouseId
1408 ankur.sing 2386 
    args.providerId = providerId
3064 chandransh 2387 
    args.cod = cod
4910 phani.kuma 2388 
    args.orderIds = orderIds
1408 ankur.sing 2389 
    args.write(self._oprot)
2390 
    self._oprot.writeMessageEnd()
2391 
    self._oprot.trans.flush()
2392 
 
4910 phani.kuma 2393 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2394 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2395 
    if mtype == TMessageType.EXCEPTION:
2396 
      x = TApplicationException()
2397 
      x.read(self._iprot)
2398 
      self._iprot.readMessageEnd()
2399 
      raise x
4910 phani.kuma 2400 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2401 
    result.read(self._iprot)
2402 
    self._iprot.readMessageEnd()
3431 rajveer 2403 
    if result.success is not None:
1408 ankur.sing 2404 
      return result.success
3431 rajveer 2405 
    if result.ex is not None:
3064 chandransh 2406 
      raise result.ex
4910 phani.kuma 2407 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2408 
 
4910 phani.kuma 2409 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2410 
    """
4910 phani.kuma 2411 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2412 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2413 
 
2414 
    Parameters:
2415 
     - providerId
4910 phani.kuma 2416 
     - pickupDetails
4410 rajveer 2417 
    """
4910 phani.kuma 2418 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2419 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2420 
 
4910 phani.kuma 2421 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2422 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2423 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2424 
    args.providerId = providerId
4910 phani.kuma 2425 
    args.pickupDetails = pickupDetails
4410 rajveer 2426 
    args.write(self._oprot)
2427 
    self._oprot.writeMessageEnd()
2428 
    self._oprot.trans.flush()
2429 
 
4910 phani.kuma 2430 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2432 
    if mtype == TMessageType.EXCEPTION:
2433 
      x = TApplicationException()
2434 
      x.read(self._iprot)
2435 
      self._iprot.readMessageEnd()
2436 
      raise x
4910 phani.kuma 2437 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2438 
    result.read(self._iprot)
2439 
    self._iprot.readMessageEnd()
2440 
    if result.ex is not None:
2441 
      raise result.ex
4910 phani.kuma 2442 
    return
4410 rajveer 2443 
 
4910 phani.kuma 2444 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2445 
    """
3064 chandransh 2446 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2447 
 
94 ashish 2448 
    Parameters:
3064 chandransh 2449 
     - providerId
304 ashish 2450 
    """
4910 phani.kuma 2451 
    self.send_getOrdersNotPickedUp(providerId)
2452 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2453 
 
4910 phani.kuma 2454 
  def send_getOrdersNotPickedUp(self, providerId):
2455 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2456 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2457 
    args.providerId = providerId
304 ashish 2458 
    args.write(self._oprot)
2459 
    self._oprot.writeMessageEnd()
2460 
    self._oprot.trans.flush()
2461 
 
4910 phani.kuma 2462 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2463 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2464 
    if mtype == TMessageType.EXCEPTION:
2465 
      x = TApplicationException()
2466 
      x.read(self._iprot)
2467 
      self._iprot.readMessageEnd()
2468 
      raise x
4910 phani.kuma 2469 
    result = getOrdersNotPickedUp_result()
304 ashish 2470 
    result.read(self._iprot)
2471 
    self._iprot.readMessageEnd()
3431 rajveer 2472 
    if result.success is not None:
304 ashish 2473 
      return result.success
4910 phani.kuma 2474 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2475 
 
3064 chandransh 2476 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2477 
    """
3064 chandransh 2478 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2479 
    the name of the receiver.
2480 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2481 
 
304 ashish 2482 
    Parameters:
3064 chandransh 2483 
     - providerId
2484 
     - deliveredOrders
304 ashish 2485 
    """
3064 chandransh 2486 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2487 
    self.recv_markOrdersAsDelivered()
304 ashish 2488 
 
3064 chandransh 2489 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2490 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2491 
    args = markOrdersAsDelivered_args()
2492 
    args.providerId = providerId
2493 
    args.deliveredOrders = deliveredOrders
304 ashish 2494 
    args.write(self._oprot)
2495 
    self._oprot.writeMessageEnd()
2496 
    self._oprot.trans.flush()
2497 
 
3064 chandransh 2498 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2499 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2500 
    if mtype == TMessageType.EXCEPTION:
2501 
      x = TApplicationException()
2502 
      x.read(self._iprot)
2503 
      self._iprot.readMessageEnd()
2504 
      raise x
3064 chandransh 2505 
    result = markOrdersAsDelivered_result()
304 ashish 2506 
    result.read(self._iprot)
2507 
    self._iprot.readMessageEnd()
3431 rajveer 2508 
    if result.ex is not None:
3064 chandransh 2509 
      raise result.ex
304 ashish 2510 
    return
2511 
 
4910 phani.kuma 2512 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2513 
    """
4910 phani.kuma 2514 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2515 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2516 
 
3064 chandransh 2517 
    Parameters:
2518 
     - providerId
2519 
     - returnedOrders
1596 ankur.sing 2520 
    """
4910 phani.kuma 2521 
    self.send_markAsRTOrders(providerId, returnedOrders)
2522 
    self.recv_markAsRTOrders()
304 ashish 2523 
 
4910 phani.kuma 2524 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2525 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2526 
    args = markAsRTOrders_args()
3064 chandransh 2527 
    args.providerId = providerId
2528 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2529 
    args.write(self._oprot)
2530 
    self._oprot.writeMessageEnd()
2531 
    self._oprot.trans.flush()
2532 
 
4910 phani.kuma 2533 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2534 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2535 
    if mtype == TMessageType.EXCEPTION:
2536 
      x = TApplicationException()
2537 
      x.read(self._iprot)
2538 
      self._iprot.readMessageEnd()
2539 
      raise x
4910 phani.kuma 2540 
    result = markAsRTOrders_result()
1596 ankur.sing 2541 
    result.read(self._iprot)
2542 
    self._iprot.readMessageEnd()
3431 rajveer 2543 
    if result.ex is not None:
3064 chandransh 2544 
      raise result.ex
2545 
    return
1596 ankur.sing 2546 
 
4910 phani.kuma 2547 
  def getRTOrders(self, providerId):
2548 
    """
2549 
    Returns a list of orders that were returned by courier.
2550 
 
2551 
    Parameters:
2552 
     - providerId
2553 
    """
2554 
    self.send_getRTOrders(providerId)
2555 
    return self.recv_getRTOrders()
2556 
 
2557 
  def send_getRTOrders(self, providerId):
2558 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2559 
    args = getRTOrders_args()
2560 
    args.providerId = providerId
2561 
    args.write(self._oprot)
2562 
    self._oprot.writeMessageEnd()
2563 
    self._oprot.trans.flush()
2564 
 
2565 
  def recv_getRTOrders(self, ):
2566 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2567 
    if mtype == TMessageType.EXCEPTION:
2568 
      x = TApplicationException()
2569 
      x.read(self._iprot)
2570 
      self._iprot.readMessageEnd()
2571 
      raise x
2572 
    result = getRTOrders_result()
2573 
    result.read(self._iprot)
2574 
    self._iprot.readMessageEnd()
2575 
    if result.success is not None:
2576 
      return result.success
2577 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2578 
 
3064 chandransh 2579 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2580 
    """
3064 chandransh 2581 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2582 
 
3064 chandransh 2583 
    Parameters:
2584 
     - providerId
2585 
     - undeliveredOrders
1627 ankur.sing 2586 
    """
3064 chandransh 2587 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2588 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2589 
 
3064 chandransh 2590 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2591 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2592 
    args = updateNonDeliveryReason_args()
2593 
    args.providerId = providerId
2594 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2595 
    args.write(self._oprot)
2596 
    self._oprot.writeMessageEnd()
2597 
    self._oprot.trans.flush()
2598 
 
3064 chandransh 2599 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2601 
    if mtype == TMessageType.EXCEPTION:
2602 
      x = TApplicationException()
2603 
      x.read(self._iprot)
2604 
      self._iprot.readMessageEnd()
2605 
      raise x
3064 chandransh 2606 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2607 
    result.read(self._iprot)
2608 
    self._iprot.readMessageEnd()
4910 phani.kuma 2609 
    if result.ex is not None:
2610 
      raise result.ex
2611 
    return
2612 
 
2613 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2614 
    """
2615 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2616 
 
2617 
    Parameters:
2618 
     - providerId
2619 
    """
2620 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2621 
    return self.recv_getNonDeliveredOrdersbyCourier()
2622 
 
2623 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2624 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2625 
    args = getNonDeliveredOrdersbyCourier_args()
2626 
    args.providerId = providerId
2627 
    args.write(self._oprot)
2628 
    self._oprot.writeMessageEnd()
2629 
    self._oprot.trans.flush()
2630 
 
2631 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2632 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2633 
    if mtype == TMessageType.EXCEPTION:
2634 
      x = TApplicationException()
2635 
      x.read(self._iprot)
2636 
      self._iprot.readMessageEnd()
2637 
      raise x
2638 
    result = getNonDeliveredOrdersbyCourier_result()
2639 
    result.read(self._iprot)
2640 
    self._iprot.readMessageEnd()
4581 phani.kuma 2641 
    if result.success is not None:
2642 
      return result.success
4910 phani.kuma 2643 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2644 
 
2645 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2646 
    """
2647 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2648 
 
2649 
    Parameters:
2650 
     - providerId
2651 
     - local_connected_orders
2652 
    """
2653 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2654 
    self.recv_markOrdersAsLocalConnected()
2655 
 
2656 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2657 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2658 
    args = markOrdersAsLocalConnected_args()
2659 
    args.providerId = providerId
2660 
    args.local_connected_orders = local_connected_orders
2661 
    args.write(self._oprot)
2662 
    self._oprot.writeMessageEnd()
2663 
    self._oprot.trans.flush()
2664 
 
2665 
  def recv_markOrdersAsLocalConnected(self, ):
2666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2667 
    if mtype == TMessageType.EXCEPTION:
2668 
      x = TApplicationException()
2669 
      x.read(self._iprot)
2670 
      self._iprot.readMessageEnd()
2671 
      raise x
2672 
    result = markOrdersAsLocalConnected_result()
2673 
    result.read(self._iprot)
2674 
    self._iprot.readMessageEnd()
3431 rajveer 2675 
    if result.ex is not None:
3064 chandransh 2676 
      raise result.ex
4910 phani.kuma 2677 
    return
1627 ankur.sing 2678 
 
4910 phani.kuma 2679 
  def getOrdersNotLocalConnected(self, providerId):
2680 
    """
2681 
    Returns a list of orders that were picked up or shipped but pending local connection.
2682 
 
2683 
    Parameters:
2684 
     - providerId
2685 
    """
2686 
    self.send_getOrdersNotLocalConnected(providerId)
2687 
    return self.recv_getOrdersNotLocalConnected()
2688 
 
2689 
  def send_getOrdersNotLocalConnected(self, providerId):
2690 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2691 
    args = getOrdersNotLocalConnected_args()
2692 
    args.providerId = providerId
2693 
    args.write(self._oprot)
2694 
    self._oprot.writeMessageEnd()
2695 
    self._oprot.trans.flush()
2696 
 
2697 
  def recv_getOrdersNotLocalConnected(self, ):
2698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2699 
    if mtype == TMessageType.EXCEPTION:
2700 
      x = TApplicationException()
2701 
      x.read(self._iprot)
2702 
      self._iprot.readMessageEnd()
2703 
      raise x
2704 
    result = getOrdersNotLocalConnected_result()
2705 
    result.read(self._iprot)
2706 
    self._iprot.readMessageEnd()
2707 
    if result.success is not None:
2708 
      return result.success
2709 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2710 
 
2711 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2712 
    """
2713 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2714 
 
2715 
    Parameters:
2716 
     - providerId
2717 
     - destination_city_reached_orders
2718 
    """
2719 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2720 
    self.recv_markOrdersAsDestinationCityReached()
2721 
 
2722 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2723 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2724 
    args = markOrdersAsDestinationCityReached_args()
2725 
    args.providerId = providerId
2726 
    args.destination_city_reached_orders = destination_city_reached_orders
2727 
    args.write(self._oprot)
2728 
    self._oprot.writeMessageEnd()
2729 
    self._oprot.trans.flush()
2730 
 
2731 
  def recv_markOrdersAsDestinationCityReached(self, ):
2732 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2733 
    if mtype == TMessageType.EXCEPTION:
2734 
      x = TApplicationException()
2735 
      x.read(self._iprot)
2736 
      self._iprot.readMessageEnd()
2737 
      raise x
2738 
    result = markOrdersAsDestinationCityReached_result()
2739 
    result.read(self._iprot)
2740 
    self._iprot.readMessageEnd()
2741 
    if result.ex is not None:
2742 
      raise result.ex
2743 
    return
2744 
 
2745 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2746 
    """
2747 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
2748 
 
2749 
    Parameters:
2750 
     - providerId
2751 
     - first_atdl_orders
2752 
    """
2753 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
2754 
    self.recv_markOrdersAsFirstDeliveryAttempted()
2755 
 
2756 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2757 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
2758 
    args = markOrdersAsFirstDeliveryAttempted_args()
2759 
    args.providerId = providerId
2760 
    args.first_atdl_orders = first_atdl_orders
2761 
    args.write(self._oprot)
2762 
    self._oprot.writeMessageEnd()
2763 
    self._oprot.trans.flush()
2764 
 
2765 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
2766 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2767 
    if mtype == TMessageType.EXCEPTION:
2768 
      x = TApplicationException()
2769 
      x.read(self._iprot)
2770 
      self._iprot.readMessageEnd()
2771 
      raise x
2772 
    result = markOrdersAsFirstDeliveryAttempted_result()
2773 
    result.read(self._iprot)
2774 
    self._iprot.readMessageEnd()
2775 
    if result.ex is not None:
2776 
      raise result.ex
2777 
    return
2778 
 
3064 chandransh 2779 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2780 
    """
3064 chandransh 2781 
    Returns the list of orders whose delivery time has passed but have not been
2782 
    delivered yet for the given provider and warehouse. To get a complete list of
2783 
    undelivered orders, pass them as -1.
2784 
    Returns an empty list if no such orders exist.
3431 rajveer 2785 
 
1886 ankur.sing 2786 
    Parameters:
3064 chandransh 2787 
     - providerId
2788 
     - warehouseId
1886 ankur.sing 2789 
    """
3064 chandransh 2790 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2791 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2792 
 
3064 chandransh 2793 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2794 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2795 
    args = getUndeliveredOrders_args()
2796 
    args.providerId = providerId
2797 
    args.warehouseId = warehouseId
1886 ankur.sing 2798 
    args.write(self._oprot)
2799 
    self._oprot.writeMessageEnd()
2800 
    self._oprot.trans.flush()
2801 
 
3064 chandransh 2802 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2803 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2804 
    if mtype == TMessageType.EXCEPTION:
2805 
      x = TApplicationException()
2806 
      x.read(self._iprot)
2807 
      self._iprot.readMessageEnd()
2808 
      raise x
3064 chandransh 2809 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2810 
    result.read(self._iprot)
2811 
    self._iprot.readMessageEnd()
3431 rajveer 2812 
    if result.success is not None:
1886 ankur.sing 2813 
      return result.success
3064 chandransh 2814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2815 
 
4783 phani.kuma 2816 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2817 
    """
2818 
    Returns the list of orders whose expected delivery date has passed but have not been
2819 
    delivered yet.
2820 
    Returns an empty list if no such orders exist.
2821 
    """
2822 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2823 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2824 
 
2825 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2826 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2827 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2828 
    args.write(self._oprot)
2829 
    self._oprot.writeMessageEnd()
2830 
    self._oprot.trans.flush()
2831 
 
2832 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2833 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2834 
    if mtype == TMessageType.EXCEPTION:
2835 
      x = TApplicationException()
2836 
      x.read(self._iprot)
2837 
      self._iprot.readMessageEnd()
2838 
      raise x
2839 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2840 
    result.read(self._iprot)
2841 
    self._iprot.readMessageEnd()
2842 
    if result.success is not None:
2843 
      return result.success
2844 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2845 
 
2536 chandransh 2846 
  def toggleDOAFlag(self, orderId):
2847 
    """
2848 
    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.
2849 
    Returns the final flag status.
2850 
    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 2851 
 
2536 chandransh 2852 
    Parameters:
2853 
     - orderId
2854 
    """
2855 
    self.send_toggleDOAFlag(orderId)
2856 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2857 
 
2536 chandransh 2858 
  def send_toggleDOAFlag(self, orderId):
2859 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2860 
    args = toggleDOAFlag_args()
2861 
    args.orderId = orderId
2862 
    args.write(self._oprot)
2863 
    self._oprot.writeMessageEnd()
2864 
    self._oprot.trans.flush()
2865 
 
2866 
  def recv_toggleDOAFlag(self, ):
2867 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2868 
    if mtype == TMessageType.EXCEPTION:
2869 
      x = TApplicationException()
2870 
      x.read(self._iprot)
2871 
      self._iprot.readMessageEnd()
2872 
      raise x
2873 
    result = toggleDOAFlag_result()
2874 
    result.read(self._iprot)
2875 
    self._iprot.readMessageEnd()
3431 rajveer 2876 
    if result.success is not None:
2536 chandransh 2877 
      return result.success
3431 rajveer 2878 
    if result.ex is not None:
2536 chandransh 2879 
      raise result.ex
2880 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2881 
 
4712 rajveer 2882 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2883 
    """
2884 
    Parameters:
2885 
     - orderId
2886 
     - deliveryTimestamp
2887 
     - receiver
2888 
    """
2889 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2890 
    self.recv_markOrderAsDelivered()
2891 
 
2892 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2893 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2894 
    args = markOrderAsDelivered_args()
2895 
    args.orderId = orderId
2896 
    args.deliveryTimestamp = deliveryTimestamp
2897 
    args.receiver = receiver
2898 
    args.write(self._oprot)
2899 
    self._oprot.writeMessageEnd()
2900 
    self._oprot.trans.flush()
2901 
 
2902 
  def recv_markOrderAsDelivered(self, ):
2903 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2904 
    if mtype == TMessageType.EXCEPTION:
2905 
      x = TApplicationException()
2906 
      x.read(self._iprot)
2907 
      self._iprot.readMessageEnd()
2908 
      raise x
2909 
    result = markOrderAsDelivered_result()
2910 
    result.read(self._iprot)
2911 
    self._iprot.readMessageEnd()
2912 
    if result.ex is not None:
2913 
      raise result.ex
2914 
    return
2915 
 
4454 rajveer 2916 
  def markOrderDoaRequestReceived(self, orderId):
2917 
    """
2918 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2919 
 
2920 
    Parameters:
2921 
     - orderId
2922 
    """
2923 
    self.send_markOrderDoaRequestReceived(orderId)
2924 
    return self.recv_markOrderDoaRequestReceived()
2925 
 
2926 
  def send_markOrderDoaRequestReceived(self, orderId):
2927 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2928 
    args = markOrderDoaRequestReceived_args()
2929 
    args.orderId = orderId
2930 
    args.write(self._oprot)
2931 
    self._oprot.writeMessageEnd()
2932 
    self._oprot.trans.flush()
2933 
 
2934 
  def recv_markOrderDoaRequestReceived(self, ):
2935 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2936 
    if mtype == TMessageType.EXCEPTION:
2937 
      x = TApplicationException()
2938 
      x.read(self._iprot)
2939 
      self._iprot.readMessageEnd()
2940 
      raise x
2941 
    result = markOrderDoaRequestReceived_result()
2942 
    result.read(self._iprot)
2943 
    self._iprot.readMessageEnd()
2944 
    if result.success is not None:
2945 
      return result.success
2946 
    if result.ex is not None:
2947 
      raise result.ex
2948 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2949 
 
2950 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2951 
    """
2952 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2953 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2954 
 
2955 
    Parameters:
2956 
     - orderId
2957 
     - isAuthorized
2958 
    """
2959 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2960 
    return self.recv_markOrderDoaRequestAuthorized()
2961 
 
2962 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2963 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2964 
    args = markOrderDoaRequestAuthorized_args()
2965 
    args.orderId = orderId
2966 
    args.isAuthorized = isAuthorized
2967 
    args.write(self._oprot)
2968 
    self._oprot.writeMessageEnd()
2969 
    self._oprot.trans.flush()
2970 
 
2971 
  def recv_markOrderDoaRequestAuthorized(self, ):
2972 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2973 
    if mtype == TMessageType.EXCEPTION:
2974 
      x = TApplicationException()
2975 
      x.read(self._iprot)
2976 
      self._iprot.readMessageEnd()
2977 
      raise x
2978 
    result = markOrderDoaRequestAuthorized_result()
2979 
    result.read(self._iprot)
2980 
    self._iprot.readMessageEnd()
2981 
    if result.success is not None:
2982 
      return result.success
2983 
    if result.ex is not None:
2984 
      raise result.ex
2985 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2986 
 
4488 rajveer 2987 
  def markOrderReturnRequestReceived(self, orderId):
2988 
    """
2989 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2990 
 
2991 
    Parameters:
2992 
     - orderId
2993 
    """
2994 
    self.send_markOrderReturnRequestReceived(orderId)
2995 
    return self.recv_markOrderReturnRequestReceived()
2996 
 
2997 
  def send_markOrderReturnRequestReceived(self, orderId):
2998 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
2999 
    args = markOrderReturnRequestReceived_args()
3000 
    args.orderId = orderId
3001 
    args.write(self._oprot)
3002 
    self._oprot.writeMessageEnd()
3003 
    self._oprot.trans.flush()
3004 
 
3005 
  def recv_markOrderReturnRequestReceived(self, ):
3006 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3007 
    if mtype == TMessageType.EXCEPTION:
3008 
      x = TApplicationException()
3009 
      x.read(self._iprot)
3010 
      self._iprot.readMessageEnd()
3011 
      raise x
3012 
    result = markOrderReturnRequestReceived_result()
3013 
    result.read(self._iprot)
3014 
    self._iprot.readMessageEnd()
3015 
    if result.success is not None:
3016 
      return result.success
3017 
    if result.ex is not None:
3018 
      raise result.ex
3019 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3020 
 
3021 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3022 
    """
3023 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3024 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3025 
 
3026 
    Parameters:
3027 
     - orderId
3028 
     - isAuthorized
3029 
    """
3030 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3031 
    return self.recv_markOrderReturnRequestAuthorized()
3032 
 
3033 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3034 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3035 
    args = markOrderReturnRequestAuthorized_args()
3036 
    args.orderId = orderId
3037 
    args.isAuthorized = isAuthorized
3038 
    args.write(self._oprot)
3039 
    self._oprot.writeMessageEnd()
3040 
    self._oprot.trans.flush()
3041 
 
3042 
  def recv_markOrderReturnRequestAuthorized(self, ):
3043 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3044 
    if mtype == TMessageType.EXCEPTION:
3045 
      x = TApplicationException()
3046 
      x.read(self._iprot)
3047 
      self._iprot.readMessageEnd()
3048 
      raise x
3049 
    result = markOrderReturnRequestAuthorized_result()
3050 
    result.read(self._iprot)
3051 
    self._iprot.readMessageEnd()
3052 
    if result.success is not None:
3053 
      return result.success
3054 
    if result.ex is not None:
3055 
      raise result.ex
3056 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3057 
 
4579 rajveer 3058 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3059 
    """
3060 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3061 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3062 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3063 
    For any other status, it returns false.
3064 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3065 
 
2536 chandransh 3066 
    Parameters:
3067 
     - orderId
4579 rajveer 3068 
     - providerId
2536 chandransh 3069 
    """
4579 rajveer 3070 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3071 
    return self.recv_requestPickupNumber()
3072 
 
4579 rajveer 3073 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3074 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3075 
    args = requestPickupNumber_args()
3076 
    args.orderId = orderId
4579 rajveer 3077 
    args.providerId = providerId
2536 chandransh 3078 
    args.write(self._oprot)
3079 
    self._oprot.writeMessageEnd()
3080 
    self._oprot.trans.flush()
3081 
 
3082 
  def recv_requestPickupNumber(self, ):
3083 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3084 
    if mtype == TMessageType.EXCEPTION:
3085 
      x = TApplicationException()
3086 
      x.read(self._iprot)
3087 
      self._iprot.readMessageEnd()
3088 
      raise x
3089 
    result = requestPickupNumber_result()
3090 
    result.read(self._iprot)
3091 
    self._iprot.readMessageEnd()
3431 rajveer 3092 
    if result.success is not None:
2536 chandransh 3093 
      return result.success
3431 rajveer 3094 
    if result.ex is not None:
2536 chandransh 3095 
      raise result.ex
3096 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3097 
 
4602 rajveer 3098 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3099 
    """
4452 rajveer 3100 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3101 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3102 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3103 
    	3. Returns true
2591 chandransh 3104 
    If the order is in any other status, it returns false.
2536 chandransh 3105 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3106 
 
2536 chandransh 3107 
    Parameters:
3108 
     - orderId
3109 
     - pickupNumber
4602 rajveer 3110 
     - providerId
2536 chandransh 3111 
    """
4602 rajveer 3112 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3113 
    return self.recv_authorizePickup()
3114 
 
4602 rajveer 3115 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3116 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3117 
    args = authorizePickup_args()
3118 
    args.orderId = orderId
3119 
    args.pickupNumber = pickupNumber
4602 rajveer 3120 
    args.providerId = providerId
2536 chandransh 3121 
    args.write(self._oprot)
3122 
    self._oprot.writeMessageEnd()
3123 
    self._oprot.trans.flush()
3124 
 
3125 
  def recv_authorizePickup(self, ):
3126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3127 
    if mtype == TMessageType.EXCEPTION:
3128 
      x = TApplicationException()
3129 
      x.read(self._iprot)
3130 
      self._iprot.readMessageEnd()
3131 
      raise x
3132 
    result = authorizePickup_result()
3133 
    result.read(self._iprot)
3134 
    self._iprot.readMessageEnd()
3431 rajveer 3135 
    if result.success is not None:
2536 chandransh 3136 
      return result.success
3431 rajveer 3137 
    if result.ex is not None:
2536 chandransh 3138 
      raise result.ex
3139 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3140 
 
2764 chandransh 3141 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3142 
    """
3143 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3144 
 
2764 chandransh 3145 
    Parameters:
3146 
     - providerId
3147 
     - pickupDetails
3148 
    """
3149 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3150 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3151 
 
3152 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3153 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3154 
    args = markDoasAsPickedUp_args()
3155 
    args.providerId = providerId
3156 
    args.pickupDetails = pickupDetails
3157 
    args.write(self._oprot)
3158 
    self._oprot.writeMessageEnd()
3159 
    self._oprot.trans.flush()
3160 
 
3161 
  def recv_markDoasAsPickedUp(self, ):
3162 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3163 
    if mtype == TMessageType.EXCEPTION:
3164 
      x = TApplicationException()
3165 
      x.read(self._iprot)
3166 
      self._iprot.readMessageEnd()
3167 
      raise x
3168 
    result = markDoasAsPickedUp_result()
3169 
    result.read(self._iprot)
3170 
    self._iprot.readMessageEnd()
4910 phani.kuma 3171 
    return
3172 
 
3173 
  def getDoasNotPickedUp(self, providerId):
3174 
    """
3175 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3176 
 
3177 
    Parameters:
3178 
     - providerId
3179 
    """
3180 
    self.send_getDoasNotPickedUp(providerId)
3181 
    return self.recv_getDoasNotPickedUp()
3182 
 
3183 
  def send_getDoasNotPickedUp(self, providerId):
3184 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3185 
    args = getDoasNotPickedUp_args()
3186 
    args.providerId = providerId
3187 
    args.write(self._oprot)
3188 
    self._oprot.writeMessageEnd()
3189 
    self._oprot.trans.flush()
3190 
 
3191 
  def recv_getDoasNotPickedUp(self, ):
3192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3193 
    if mtype == TMessageType.EXCEPTION:
3194 
      x = TApplicationException()
3195 
      x.read(self._iprot)
3196 
      self._iprot.readMessageEnd()
3197 
      raise x
3198 
    result = getDoasNotPickedUp_result()
3199 
    result.read(self._iprot)
3200 
    self._iprot.readMessageEnd()
3431 rajveer 3201 
    if result.success is not None:
2764 chandransh 3202 
      return result.success
4910 phani.kuma 3203 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3204 
 
4741 phani.kuma 3205 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3206 
    """
3207 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3208 
 
3209 
    Parameters:
3210 
     - providerId
3211 
     - pickupDetails
3212 
    """
3213 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3214 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3215 
 
3216 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3217 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3218 
    args = markReturnOrdersAsPickedUp_args()
3219 
    args.providerId = providerId
3220 
    args.pickupDetails = pickupDetails
3221 
    args.write(self._oprot)
3222 
    self._oprot.writeMessageEnd()
3223 
    self._oprot.trans.flush()
3224 
 
3225 
  def recv_markReturnOrdersAsPickedUp(self, ):
3226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3227 
    if mtype == TMessageType.EXCEPTION:
3228 
      x = TApplicationException()
3229 
      x.read(self._iprot)
3230 
      self._iprot.readMessageEnd()
3231 
      raise x
3232 
    result = markReturnOrdersAsPickedUp_result()
3233 
    result.read(self._iprot)
3234 
    self._iprot.readMessageEnd()
4910 phani.kuma 3235 
    return
3236 
 
3237 
  def getReturnOrdersNotPickedUp(self, providerId):
3238 
    """
3239 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3240 
 
3241 
    Parameters:
3242 
     - providerId
3243 
    """
3244 
    self.send_getReturnOrdersNotPickedUp(providerId)
3245 
    return self.recv_getReturnOrdersNotPickedUp()
3246 
 
3247 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3248 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3249 
    args = getReturnOrdersNotPickedUp_args()
3250 
    args.providerId = providerId
3251 
    args.write(self._oprot)
3252 
    self._oprot.writeMessageEnd()
3253 
    self._oprot.trans.flush()
3254 
 
3255 
  def recv_getReturnOrdersNotPickedUp(self, ):
3256 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3257 
    if mtype == TMessageType.EXCEPTION:
3258 
      x = TApplicationException()
3259 
      x.read(self._iprot)
3260 
      self._iprot.readMessageEnd()
3261 
      raise x
3262 
    result = getReturnOrdersNotPickedUp_result()
3263 
    result.read(self._iprot)
3264 
    self._iprot.readMessageEnd()
4741 phani.kuma 3265 
    if result.success is not None:
3266 
      return result.success
4910 phani.kuma 3267 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3268 
 
4479 rajveer 3269 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3270 
    """
4452 rajveer 3271 
    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 3272 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3273 
    If the order is in any other state, it returns false.
3274 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3275 
 
2591 chandransh 3276 
    Parameters:
3277 
     - orderId
4479 rajveer 3278 
     - receiveCondition
2591 chandransh 3279 
    """
4479 rajveer 3280 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3281 
    return self.recv_receiveReturn()
2536 chandransh 3282 
 
4479 rajveer 3283 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3284 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3285 
    args = receiveReturn_args()
2591 chandransh 3286 
    args.orderId = orderId
4479 rajveer 3287 
    args.receiveCondition = receiveCondition
2591 chandransh 3288 
    args.write(self._oprot)
3289 
    self._oprot.writeMessageEnd()
3290 
    self._oprot.trans.flush()
3291 
 
2616 chandransh 3292 
  def recv_receiveReturn(self, ):
2591 chandransh 3293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3294 
    if mtype == TMessageType.EXCEPTION:
3295 
      x = TApplicationException()
3296 
      x.read(self._iprot)
3297 
      self._iprot.readMessageEnd()
3298 
      raise x
2616 chandransh 3299 
    result = receiveReturn_result()
2591 chandransh 3300 
    result.read(self._iprot)
3301 
    self._iprot.readMessageEnd()
3431 rajveer 3302 
    if result.success is not None:
2591 chandransh 3303 
      return result.success
3431 rajveer 3304 
    if result.ex is not None:
2591 chandransh 3305 
      raise result.ex
2616 chandransh 3306 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3307 
 
3308 
  def validateDoa(self, orderId, isValid):
3309 
    """
4452 rajveer 3310 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3311 
    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 3312 
    If the order is in any other state, it returns false.
3313 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3314 
 
2591 chandransh 3315 
    Parameters:
3316 
     - orderId
3317 
     - isValid
3318 
    """
3319 
    self.send_validateDoa(orderId, isValid)
3320 
    return self.recv_validateDoa()
3321 
 
3322 
  def send_validateDoa(self, orderId, isValid):
3323 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3324 
    args = validateDoa_args()
3325 
    args.orderId = orderId
3326 
    args.isValid = isValid
3327 
    args.write(self._oprot)
3328 
    self._oprot.writeMessageEnd()
3329 
    self._oprot.trans.flush()
3330 
 
3331 
  def recv_validateDoa(self, ):
3332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3333 
    if mtype == TMessageType.EXCEPTION:
3334 
      x = TApplicationException()
3335 
      x.read(self._iprot)
3336 
      self._iprot.readMessageEnd()
3337 
      raise x
3338 
    result = validateDoa_result()
3339 
    result.read(self._iprot)
3340 
    self._iprot.readMessageEnd()
3431 rajveer 3341 
    if result.success is not None:
2591 chandransh 3342 
      return result.success
3431 rajveer 3343 
    if result.ex is not None:
2591 chandransh 3344 
      raise result.ex
3345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3346 
 
4495 rajveer 3347 
  def validateReturnProduct(self, orderId, isUsable):
3348 
    """
3349 
    Parameters:
3350 
     - orderId
3351 
     - isUsable
3352 
    """
3353 
    self.send_validateReturnProduct(orderId, isUsable)
3354 
    return self.recv_validateReturnProduct()
3355 
 
3356 
  def send_validateReturnProduct(self, orderId, isUsable):
3357 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3358 
    args = validateReturnProduct_args()
3359 
    args.orderId = orderId
3360 
    args.isUsable = isUsable
3361 
    args.write(self._oprot)
3362 
    self._oprot.writeMessageEnd()
3363 
    self._oprot.trans.flush()
3364 
 
3365 
  def recv_validateReturnProduct(self, ):
3366 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3367 
    if mtype == TMessageType.EXCEPTION:
3368 
      x = TApplicationException()
3369 
      x.read(self._iprot)
3370 
      self._iprot.readMessageEnd()
3371 
      raise x
3372 
    result = validateReturnProduct_result()
3373 
    result.read(self._iprot)
3374 
    self._iprot.readMessageEnd()
3375 
    if result.success is not None:
3376 
      return result.success
3377 
    if result.ex is not None:
3378 
      raise result.ex
3379 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3380 
 
2616 chandransh 3381 
  def reshipOrder(self, orderId):
3382 
    """
4484 rajveer 3383 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3384 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3385 
    	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 3386 
 
3387 
    If the order is in DOA_CERT_VALID state, it does the following:
3388 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3389 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3390 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3391 
 
2616 chandransh 3392 
    Returns the id of the newly created order.
3431 rajveer 3393 
 
2616 chandransh 3394 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3395 
 
2616 chandransh 3396 
    Parameters:
3397 
     - orderId
3398 
    """
3399 
    self.send_reshipOrder(orderId)
3400 
    return self.recv_reshipOrder()
2591 chandransh 3401 
 
2616 chandransh 3402 
  def send_reshipOrder(self, orderId):
3403 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3404 
    args = reshipOrder_args()
3405 
    args.orderId = orderId
3406 
    args.write(self._oprot)
3407 
    self._oprot.writeMessageEnd()
3408 
    self._oprot.trans.flush()
3409 
 
3410 
  def recv_reshipOrder(self, ):
3411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3412 
    if mtype == TMessageType.EXCEPTION:
3413 
      x = TApplicationException()
3414 
      x.read(self._iprot)
3415 
      self._iprot.readMessageEnd()
3416 
      raise x
3417 
    result = reshipOrder_result()
3418 
    result.read(self._iprot)
3419 
    self._iprot.readMessageEnd()
3431 rajveer 3420 
    if result.success is not None:
2616 chandransh 3421 
      return result.success
3431 rajveer 3422 
    if result.ex is not None:
2616 chandransh 3423 
      raise result.ex
3424 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3425 
 
3226 chandransh 3426 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3427 
    """
4484 rajveer 3428 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3429 
    	1. Creates a refund request for batch processing.
3430 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3431 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3432 
 
2616 chandransh 3433 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3434 
    	1. Creates a refund request for batch processing.
3226 chandransh 3435 
    	2. Cancels the reservation of the item in the warehouse.
3436 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3437 
 
3226 chandransh 3438 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3439 
    	1. Cancels the reservation of the item in the warehouse.
3440 
    	2. Marks the current order as CANCELED.
3441 
 
3442 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3443 
 
2616 chandransh 3444 
    Returns True if it is successful, False otherwise.
3431 rajveer 3445 
 
2616 chandransh 3446 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3447 
 
2616 chandransh 3448 
    Parameters:
3449 
     - orderId
3226 chandransh 3450 
     - refundedBy
3451 
     - reason
2616 chandransh 3452 
    """
3226 chandransh 3453 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3454 
    return self.recv_refundOrder()
3455 
 
3226 chandransh 3456 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3457 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3458 
    args = refundOrder_args()
3459 
    args.orderId = orderId
3226 chandransh 3460 
    args.refundedBy = refundedBy
3461 
    args.reason = reason
2616 chandransh 3462 
    args.write(self._oprot)
3463 
    self._oprot.writeMessageEnd()
3464 
    self._oprot.trans.flush()
3465 
 
3466 
  def recv_refundOrder(self, ):
3467 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3468 
    if mtype == TMessageType.EXCEPTION:
3469 
      x = TApplicationException()
3470 
      x.read(self._iprot)
3471 
      self._iprot.readMessageEnd()
3472 
      raise x
3473 
    result = refundOrder_result()
3474 
    result.read(self._iprot)
3475 
    self._iprot.readMessageEnd()
3431 rajveer 3476 
    if result.success is not None:
2616 chandransh 3477 
      return result.success
3431 rajveer 3478 
    if result.ex is not None:
2616 chandransh 3479 
      raise result.ex
3480 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3481 
 
2690 chandransh 3482 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3483 
    """
3484 
    Get all return orders created between the from and to dates for the given warehouse.
3485 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3486 
 
2690 chandransh 3487 
    Parameters:
3488 
     - warehouseId
3489 
     - fromDate
3490 
     - toDate
3491 
    """
3492 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3493 
    return self.recv_getReturnOrders()
2616 chandransh 3494 
 
2690 chandransh 3495 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3496 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3497 
    args = getReturnOrders_args()
3498 
    args.warehouseId = warehouseId
3499 
    args.fromDate = fromDate
3500 
    args.toDate = toDate
3501 
    args.write(self._oprot)
3502 
    self._oprot.writeMessageEnd()
3503 
    self._oprot.trans.flush()
3504 
 
3505 
  def recv_getReturnOrders(self, ):
3506 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3507 
    if mtype == TMessageType.EXCEPTION:
3508 
      x = TApplicationException()
3509 
      x.read(self._iprot)
3510 
      self._iprot.readMessageEnd()
3511 
      raise x
3512 
    result = getReturnOrders_result()
3513 
    result.read(self._iprot)
3514 
    self._iprot.readMessageEnd()
3431 rajveer 3515 
    if result.success is not None:
2690 chandransh 3516 
      return result.success
3517 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3518 
 
2700 chandransh 3519 
  def getReturnOrder(self, id):
3520 
    """
3521 
    Returns the ReturnOrder corresponding to the given id.
3522 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3523 
 
2700 chandransh 3524 
    Parameters:
3525 
     - id
3526 
    """
3527 
    self.send_getReturnOrder(id)
3528 
    return self.recv_getReturnOrder()
3529 
 
3530 
  def send_getReturnOrder(self, id):
3531 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3532 
    args = getReturnOrder_args()
3533 
    args.id = id
3534 
    args.write(self._oprot)
3535 
    self._oprot.writeMessageEnd()
3536 
    self._oprot.trans.flush()
3537 
 
3538 
  def recv_getReturnOrder(self, ):
3539 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3540 
    if mtype == TMessageType.EXCEPTION:
3541 
      x = TApplicationException()
3542 
      x.read(self._iprot)
3543 
      self._iprot.readMessageEnd()
3544 
      raise x
3545 
    result = getReturnOrder_result()
3546 
    result.read(self._iprot)
3547 
    self._iprot.readMessageEnd()
3431 rajveer 3548 
    if result.success is not None:
2700 chandransh 3549 
      return result.success
3431 rajveer 3550 
    if result.ex is not None:
2700 chandransh 3551 
      raise result.ex
3552 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3553 
 
2690 chandransh 3554 
  def processReturn(self, returnOrderId):
3555 
    """
3556 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3557 
 
2690 chandransh 3558 
    Parameters:
3559 
     - returnOrderId
3560 
    """
3561 
    self.send_processReturn(returnOrderId)
3562 
    self.recv_processReturn()
3563 
 
3564 
  def send_processReturn(self, returnOrderId):
3565 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3566 
    args = processReturn_args()
3567 
    args.returnOrderId = returnOrderId
3568 
    args.write(self._oprot)
3569 
    self._oprot.writeMessageEnd()
3570 
    self._oprot.trans.flush()
3571 
 
3572 
  def recv_processReturn(self, ):
3573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3574 
    if mtype == TMessageType.EXCEPTION:
3575 
      x = TApplicationException()
3576 
      x.read(self._iprot)
3577 
      self._iprot.readMessageEnd()
3578 
      raise x
3579 
    result = processReturn_result()
3580 
    result.read(self._iprot)
3581 
    self._iprot.readMessageEnd()
3431 rajveer 3582 
    if result.ex is not None:
2690 chandransh 3583 
      raise result.ex
3584 
    return
3585 
 
3451 chandransh 3586 
  def updateWeight(self, orderId, weight):
3587 
    """
3588 
    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 3589 
 
3451 chandransh 3590 
    Parameters:
3591 
     - orderId
3592 
     - weight
3593 
    """
3594 
    self.send_updateWeight(orderId, weight)
3595 
    return self.recv_updateWeight()
3596 
 
3597 
  def send_updateWeight(self, orderId, weight):
3598 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3599 
    args = updateWeight_args()
3600 
    args.orderId = orderId
3601 
    args.weight = weight
3602 
    args.write(self._oprot)
3603 
    self._oprot.writeMessageEnd()
3604 
    self._oprot.trans.flush()
3605 
 
3606 
  def recv_updateWeight(self, ):
3607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3608 
    if mtype == TMessageType.EXCEPTION:
3609 
      x = TApplicationException()
3610 
      x.read(self._iprot)
3611 
      self._iprot.readMessageEnd()
3612 
      raise x
3613 
    result = updateWeight_result()
3614 
    result.read(self._iprot)
3615 
    self._iprot.readMessageEnd()
3616 
    if result.success is not None:
3617 
      return result.success
3618 
    if result.ex is not None:
3619 
      raise result.ex
3620 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3621 
 
3469 chandransh 3622 
  def changeItem(self, orderId, itemId):
3623 
    """
3624 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3625 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3626 
 
3469 chandransh 3627 
    Parameters:
3628 
     - orderId
3629 
     - itemId
3630 
    """
3631 
    self.send_changeItem(orderId, itemId)
3632 
    return self.recv_changeItem()
3633 
 
3634 
  def send_changeItem(self, orderId, itemId):
3635 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3636 
    args = changeItem_args()
3637 
    args.orderId = orderId
3638 
    args.itemId = itemId
3639 
    args.write(self._oprot)
3640 
    self._oprot.writeMessageEnd()
3641 
    self._oprot.trans.flush()
3642 
 
3643 
  def recv_changeItem(self, ):
3644 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3645 
    if mtype == TMessageType.EXCEPTION:
3646 
      x = TApplicationException()
3647 
      x.read(self._iprot)
3648 
      self._iprot.readMessageEnd()
3649 
      raise x
3650 
    result = changeItem_result()
3651 
    result.read(self._iprot)
3652 
    self._iprot.readMessageEnd()
3653 
    if result.success is not None:
3654 
      return result.success
3655 
    if result.ex is not None:
3656 
      raise result.ex
3657 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3658 
 
3659 
  def shiftToWarehouse(self, orderId, warehouseId):
3660 
    """
3661 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3662 
 
3663 
    Parameters:
3664 
     - orderId
3665 
     - warehouseId
3666 
    """
3667 
    self.send_shiftToWarehouse(orderId, warehouseId)
3668 
    return self.recv_shiftToWarehouse()
3669 
 
3670 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3671 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3672 
    args = shiftToWarehouse_args()
3673 
    args.orderId = orderId
3674 
    args.warehouseId = warehouseId
3675 
    args.write(self._oprot)
3676 
    self._oprot.writeMessageEnd()
3677 
    self._oprot.trans.flush()
3678 
 
3679 
  def recv_shiftToWarehouse(self, ):
3680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3681 
    if mtype == TMessageType.EXCEPTION:
3682 
      x = TApplicationException()
3683 
      x.read(self._iprot)
3684 
      self._iprot.readMessageEnd()
3685 
      raise x
3686 
    result = shiftToWarehouse_result()
3687 
    result.read(self._iprot)
3688 
    self._iprot.readMessageEnd()
3689 
    if result.success is not None:
3690 
      return result.success
3691 
    if result.ex is not None:
3692 
      raise result.ex
3693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3694 
 
4647 rajveer 3695 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3696 
    """
3697 
    Adds the given delay reason to the given order.
3986 chandransh 3698 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3699 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3700 
 
3553 chandransh 3701 
    Parameters:
3702 
     - orderId
3703 
     - delayReason
3986 chandransh 3704 
     - furtherDelay
4647 rajveer 3705 
     - delayReasonText
3553 chandransh 3706 
    """
4647 rajveer 3707 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3708 
    return self.recv_addDelayReason()
3709 
 
4647 rajveer 3710 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3711 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3712 
    args = addDelayReason_args()
3713 
    args.orderId = orderId
3714 
    args.delayReason = delayReason
3986 chandransh 3715 
    args.furtherDelay = furtherDelay
4647 rajveer 3716 
    args.delayReasonText = delayReasonText
3553 chandransh 3717 
    args.write(self._oprot)
3718 
    self._oprot.writeMessageEnd()
3719 
    self._oprot.trans.flush()
3720 
 
3721 
  def recv_addDelayReason(self, ):
3722 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3723 
    if mtype == TMessageType.EXCEPTION:
3724 
      x = TApplicationException()
3725 
      x.read(self._iprot)
3726 
      self._iprot.readMessageEnd()
3727 
      raise x
3728 
    result = addDelayReason_result()
3729 
    result.read(self._iprot)
3730 
    self._iprot.readMessageEnd()
3731 
    if result.success is not None:
3732 
      return result.success
3733 
    if result.ex is not None:
3734 
      raise result.ex
3735 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3736 
 
3956 chandransh 3737 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3738 
    """
3739 
    Marks the COD orders with given AWB nos. as having been processed.
3740 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3741 
 
3956 chandransh 3742 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3743 
    1. There is no order corresponding to an AWB number.
3744 
    2. The captured amount for a payment exceeds the total payment.
3745 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3746 
 
3747 
    Parameters:
3748 
     - collectedAmountMap
3749 
     - xferBy
3750 
     - xferTxnId
3751 
     - xferDate
3752 
    """
3753 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3754 
    return self.recv_reconcileCodCollection()
3755 
 
3756 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3757 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3758 
    args = reconcileCodCollection_args()
3759 
    args.collectedAmountMap = collectedAmountMap
3760 
    args.xferBy = xferBy
3761 
    args.xferTxnId = xferTxnId
3762 
    args.xferDate = xferDate
3763 
    args.write(self._oprot)
3764 
    self._oprot.writeMessageEnd()
3765 
    self._oprot.trans.flush()
3766 
 
3767 
  def recv_reconcileCodCollection(self, ):
3768 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3769 
    if mtype == TMessageType.EXCEPTION:
3770 
      x = TApplicationException()
3771 
      x.read(self._iprot)
3772 
      self._iprot.readMessageEnd()
3773 
      raise x
3774 
    result = reconcileCodCollection_result()
3775 
    result.read(self._iprot)
3776 
    self._iprot.readMessageEnd()
3777 
    if result.success is not None:
3778 
      return result.success
3779 
    if result.ex is not None:
3780 
      raise result.ex
3781 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3782 
 
4008 mandeep.dh 3783 
  def getTransactionsRequiringExtraProcessing(self, category):
3784 
    """
4065 mandeep.dh 3785 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3786 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3787 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3788 
 
4008 mandeep.dh 3789 
    Parameters:
3790 
     - category
3791 
    """
3792 
    self.send_getTransactionsRequiringExtraProcessing(category)
3793 
    return self.recv_getTransactionsRequiringExtraProcessing()
3794 
 
3795 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3796 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3797 
    args = getTransactionsRequiringExtraProcessing_args()
3798 
    args.category = category
3799 
    args.write(self._oprot)
3800 
    self._oprot.writeMessageEnd()
3801 
    self._oprot.trans.flush()
3802 
 
3803 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3805 
    if mtype == TMessageType.EXCEPTION:
3806 
      x = TApplicationException()
3807 
      x.read(self._iprot)
3808 
      self._iprot.readMessageEnd()
3809 
      raise x
3810 
    result = getTransactionsRequiringExtraProcessing_result()
3811 
    result.read(self._iprot)
3812 
    self._iprot.readMessageEnd()
3813 
    if result.success is not None:
3814 
      return result.success
3815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3816 
 
3817 
  def markTransactionAsProcessed(self, transactionId, category):
3818 
    """
3819 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3820 
    It essentially deletes the transaction id record for a particular
3821 
    processing type category (if present) from DB.
3822 
    This is currently used by CRM application.
4008 mandeep.dh 3823 
 
3824 
    Parameters:
3825 
     - transactionId
3826 
     - category
3827 
    """
3828 
    self.send_markTransactionAsProcessed(transactionId, category)
3829 
    self.recv_markTransactionAsProcessed()
3830 
 
3831 
  def send_markTransactionAsProcessed(self, transactionId, category):
3832 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3833 
    args = markTransactionAsProcessed_args()
3834 
    args.transactionId = transactionId
3835 
    args.category = category
3836 
    args.write(self._oprot)
3837 
    self._oprot.writeMessageEnd()
3838 
    self._oprot.trans.flush()
3839 
 
3840 
  def recv_markTransactionAsProcessed(self, ):
3841 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3842 
    if mtype == TMessageType.EXCEPTION:
3843 
      x = TApplicationException()
3844 
      x.read(self._iprot)
3845 
      self._iprot.readMessageEnd()
3846 
      raise x
3847 
    result = markTransactionAsProcessed_result()
3848 
    result.read(self._iprot)
3849 
    self._iprot.readMessageEnd()
3850 
    return
3851 
 
4018 chandransh 3852 
  def getItemWiseRiskyOrdersCount(self, ):
3853 
    """
3854 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3855 
    is defined as one whose shipping date is about to expire.
3856 
    """
3857 
    self.send_getItemWiseRiskyOrdersCount()
3858 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3859 
 
4018 chandransh 3860 
  def send_getItemWiseRiskyOrdersCount(self, ):
3861 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3862 
    args = getItemWiseRiskyOrdersCount_args()
3863 
    args.write(self._oprot)
3864 
    self._oprot.writeMessageEnd()
3865 
    self._oprot.trans.flush()
3866 
 
3867 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3868 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3869 
    if mtype == TMessageType.EXCEPTION:
3870 
      x = TApplicationException()
3871 
      x.read(self._iprot)
3872 
      self._iprot.readMessageEnd()
3873 
      raise x
3874 
    result = getItemWiseRiskyOrdersCount_result()
3875 
    result.read(self._iprot)
3876 
    self._iprot.readMessageEnd()
3877 
    if result.success is not None:
3878 
      return result.success
3879 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3880 
 
4295 varun.gupt 3881 
  def getOrdersForItemIds(self, itemIds):
3882 
    """
3883 
    Returns a list of all orders which have items with given id
3884 
 
3885 
    Parameters:
3886 
     - itemIds
3887 
    """
3888 
    self.send_getOrdersForItemIds(itemIds)
3889 
    return self.recv_getOrdersForItemIds()
3890 
 
3891 
  def send_getOrdersForItemIds(self, itemIds):
3892 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3893 
    args = getOrdersForItemIds_args()
3894 
    args.itemIds = itemIds
3895 
    args.write(self._oprot)
3896 
    self._oprot.writeMessageEnd()
3897 
    self._oprot.trans.flush()
3898 
 
3899 
  def recv_getOrdersForItemIds(self, ):
3900 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3901 
    if mtype == TMessageType.EXCEPTION:
3902 
      x = TApplicationException()
3903 
      x.read(self._iprot)
3904 
      self._iprot.readMessageEnd()
3905 
      raise x
3906 
    result = getOrdersForItemIds_result()
3907 
    result.read(self._iprot)
3908 
    self._iprot.readMessageEnd()
3909 
    if result.success is not None:
3910 
      return result.success
3911 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3912 
 
4247 rajveer 3913 
  def markOrderCancellationRequestReceived(self, orderId):
3914 
    """
3915 
    Mark order as cancellation request received. If customer sends request of cancellation of
3916 
    a particular order, this method will be called. It will just change status of the order
3917 
    depending on its current status. It also records the previous status, so that we can move
3918 
    back to that status if cancellation request is denied.
4018 chandransh 3919 
 
4247 rajveer 3920 
    Parameters:
3921 
     - orderId
3922 
    """
3923 
    self.send_markOrderCancellationRequestReceived(orderId)
3924 
    self.recv_markOrderCancellationRequestReceived()
3925 
 
3926 
  def send_markOrderCancellationRequestReceived(self, orderId):
3927 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3928 
    args = markOrderCancellationRequestReceived_args()
3929 
    args.orderId = orderId
3930 
    args.write(self._oprot)
3931 
    self._oprot.writeMessageEnd()
3932 
    self._oprot.trans.flush()
3933 
 
3934 
  def recv_markOrderCancellationRequestReceived(self, ):
3935 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3936 
    if mtype == TMessageType.EXCEPTION:
3937 
      x = TApplicationException()
3938 
      x.read(self._iprot)
3939 
      self._iprot.readMessageEnd()
3940 
      raise x
3941 
    result = markOrderCancellationRequestReceived_result()
3942 
    result.read(self._iprot)
3943 
    self._iprot.readMessageEnd()
3944 
    if result.ex is not None:
3945 
      raise result.ex
3946 
    return
3947 
 
3948 
  def markOrderCancellationRequestConfirmed(self, orderId):
3949 
    """
3950 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3951 
    cancellation request confirmed. After this OM will be able to cancel the order.
3952 
 
3953 
    Parameters:
3954 
     - orderId
3955 
    """
3956 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3957 
    self.recv_markOrderCancellationRequestConfirmed()
3958 
 
3959 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3960 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3961 
    args = markOrderCancellationRequestConfirmed_args()
3962 
    args.orderId = orderId
3963 
    args.write(self._oprot)
3964 
    self._oprot.writeMessageEnd()
3965 
    self._oprot.trans.flush()
3966 
 
3967 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3968 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3969 
    if mtype == TMessageType.EXCEPTION:
3970 
      x = TApplicationException()
3971 
      x.read(self._iprot)
3972 
      self._iprot.readMessageEnd()
3973 
      raise x
3974 
    result = markOrderCancellationRequestConfirmed_result()
3975 
    result.read(self._iprot)
3976 
    self._iprot.readMessageEnd()
3977 
    if result.ex is not None:
3978 
      raise result.ex
3979 
    return
3980 
 
3981 
  def markOrderCancellationRequestDenied(self, orderId):
3982 
    """
3983 
    If we decide to not to cancel order, we will move the order ro previous status.
3984 
 
3985 
    Parameters:
3986 
     - orderId
3987 
    """
3988 
    self.send_markOrderCancellationRequestDenied(orderId)
3989 
    self.recv_markOrderCancellationRequestDenied()
3990 
 
3991 
  def send_markOrderCancellationRequestDenied(self, orderId):
3992 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3993 
    args = markOrderCancellationRequestDenied_args()
3994 
    args.orderId = orderId
3995 
    args.write(self._oprot)
3996 
    self._oprot.writeMessageEnd()
3997 
    self._oprot.trans.flush()
3998 
 
3999 
  def recv_markOrderCancellationRequestDenied(self, ):
4000 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4001 
    if mtype == TMessageType.EXCEPTION:
4002 
      x = TApplicationException()
4003 
      x.read(self._iprot)
4004 
      self._iprot.readMessageEnd()
4005 
      raise x
4006 
    result = markOrderCancellationRequestDenied_result()
4007 
    result.read(self._iprot)
4008 
    self._iprot.readMessageEnd()
4009 
    if result.ex is not None:
4010 
      raise result.ex
4011 
    return
4012 
 
4258 rajveer 4013 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4014 
    """
4258 rajveer 4015 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4016 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4017 
 
4018 
    Parameters:
4258 rajveer 4019 
     - transactionId
4247 rajveer 4020 
    """
4258 rajveer 4021 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4022 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4023 
 
4258 rajveer 4024 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4025 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4026 
    args = markTransactionAsPaymentFlagRemoved_args()
4027 
    args.transactionId = transactionId
4247 rajveer 4028 
    args.write(self._oprot)
4029 
    self._oprot.writeMessageEnd()
4030 
    self._oprot.trans.flush()
4031 
 
4258 rajveer 4032 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4033 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4034 
    if mtype == TMessageType.EXCEPTION:
4035 
      x = TApplicationException()
4036 
      x.read(self._iprot)
4037 
      self._iprot.readMessageEnd()
4038 
      raise x
4258 rajveer 4039 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4040 
    result.read(self._iprot)
4041 
    self._iprot.readMessageEnd()
4042 
    if result.ex is not None:
4043 
      raise result.ex
4044 
    return
4045 
 
4259 anupam.sin 4046 
  def refundTransaction(self, transactionId, refundedBy, reason):
4047 
    """
4048 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4049 
    need to be cancelled
4247 rajveer 4050 
 
4259 anupam.sin 4051 
    Parameters:
4052 
     - transactionId
4053 
     - refundedBy
4054 
     - reason
4055 
    """
4056 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4057 
    self.recv_refundTransaction()
4058 
 
4059 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4060 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4061 
    args = refundTransaction_args()
4062 
    args.transactionId = transactionId
4063 
    args.refundedBy = refundedBy
4064 
    args.reason = reason
4065 
    args.write(self._oprot)
4066 
    self._oprot.writeMessageEnd()
4067 
    self._oprot.trans.flush()
4068 
 
4069 
  def recv_refundTransaction(self, ):
4070 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4071 
    if mtype == TMessageType.EXCEPTION:
4072 
      x = TApplicationException()
4073 
      x.read(self._iprot)
4074 
      self._iprot.readMessageEnd()
4075 
      raise x
4076 
    result = refundTransaction_result()
4077 
    result.read(self._iprot)
4078 
    self._iprot.readMessageEnd()
4079 
    if result.ex is not None:
4080 
      raise result.ex
4081 
    return
4082 
 
4324 mandeep.dh 4083 
  def updateShipmentAddress(self, orderId, addressId):
4084 
    """
4085 
    Updates shipment address of an order. Delivery and shipping date estimates
4086 
    etc. are also updated here.
4087 
 
4088 
    Throws TransactionServiceException in case address change is not
4089 
    possible due to certain reasons such as new pincode in address is
4090 
    not serviceable etc.
4091 
 
4092 
    Parameters:
4093 
     - orderId
4094 
     - addressId
4095 
    """
4096 
    self.send_updateShipmentAddress(orderId, addressId)
4097 
    self.recv_updateShipmentAddress()
4098 
 
4099 
  def send_updateShipmentAddress(self, orderId, addressId):
4100 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4101 
    args = updateShipmentAddress_args()
4102 
    args.orderId = orderId
4103 
    args.addressId = addressId
4104 
    args.write(self._oprot)
4105 
    self._oprot.writeMessageEnd()
4106 
    self._oprot.trans.flush()
4107 
 
4108 
  def recv_updateShipmentAddress(self, ):
4109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4110 
    if mtype == TMessageType.EXCEPTION:
4111 
      x = TApplicationException()
4112 
      x.read(self._iprot)
4113 
      self._iprot.readMessageEnd()
4114 
      raise x
4115 
    result = updateShipmentAddress_result()
4116 
    result.read(self._iprot)
4117 
    self._iprot.readMessageEnd()
4118 
    if result.ex is not None:
4119 
      raise result.ex
4120 
    return
4121 
 
4285 rajveer 4122 
  def acceptOrdersForItemId(self, itemId, inventory):
4123 
    """
4124 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4125 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4126 
 
4285 rajveer 4127 
    Parameters:
4128 
     - itemId
4129 
     - inventory
4130 
    """
4131 
    self.send_acceptOrdersForItemId(itemId, inventory)
4132 
    return self.recv_acceptOrdersForItemId()
4133 
 
4134 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4135 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4136 
    args = acceptOrdersForItemId_args()
4137 
    args.itemId = itemId
4138 
    args.inventory = inventory
4139 
    args.write(self._oprot)
4140 
    self._oprot.writeMessageEnd()
4141 
    self._oprot.trans.flush()
4142 
 
4143 
  def recv_acceptOrdersForItemId(self, ):
4144 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4145 
    if mtype == TMessageType.EXCEPTION:
4146 
      x = TApplicationException()
4147 
      x.read(self._iprot)
4148 
      self._iprot.readMessageEnd()
4149 
      raise x
4150 
    result = acceptOrdersForItemId_result()
4151 
    result.read(self._iprot)
4152 
    self._iprot.readMessageEnd()
4153 
    if result.success is not None:
4154 
      return result.success
4155 
    if result.ex is not None:
4156 
      raise result.ex
4157 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4158 
 
4369 rajveer 4159 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4160 
    """
4161 
    Parameters:
4162 
     - vendorId
4163 
     - itemId
4164 
     - quantity
4165 
     - estimate
4369 rajveer 4166 
     - isReminder
4303 rajveer 4167 
    """
4369 rajveer 4168 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4169 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4170 
 
4369 rajveer 4171 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4172 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4173 
    args = markOrdersAsPORaised_args()
4174 
    args.vendorId = vendorId
4175 
    args.itemId = itemId
4176 
    args.quantity = quantity
4177 
    args.estimate = estimate
4369 rajveer 4178 
    args.isReminder = isReminder
4303 rajveer 4179 
    args.write(self._oprot)
4180 
    self._oprot.writeMessageEnd()
4181 
    self._oprot.trans.flush()
4182 
 
4183 
  def recv_markOrdersAsPORaised(self, ):
4184 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4185 
    if mtype == TMessageType.EXCEPTION:
4186 
      x = TApplicationException()
4187 
      x.read(self._iprot)
4188 
      self._iprot.readMessageEnd()
4189 
      raise x
4190 
    result = markOrdersAsPORaised_result()
4191 
    result.read(self._iprot)
4192 
    self._iprot.readMessageEnd()
4193 
    if result.ex is not None:
4194 
      raise result.ex
4195 
    return
4196 
 
4369 rajveer 4197 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4198 
    """
4199 
    Parameters:
4200 
     - vendorId
4201 
     - itemId
4202 
     - quantity
4203 
     - estimate
4369 rajveer 4204 
     - isReminder
4303 rajveer 4205 
    """
4369 rajveer 4206 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4207 
    self.recv_markOrdersAsReversalInitiated()
4208 
 
4369 rajveer 4209 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4210 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4211 
    args = markOrdersAsReversalInitiated_args()
4212 
    args.vendorId = vendorId
4213 
    args.itemId = itemId
4214 
    args.quantity = quantity
4215 
    args.estimate = estimate
4369 rajveer 4216 
    args.isReminder = isReminder
4303 rajveer 4217 
    args.write(self._oprot)
4218 
    self._oprot.writeMessageEnd()
4219 
    self._oprot.trans.flush()
4220 
 
4221 
  def recv_markOrdersAsReversalInitiated(self, ):
4222 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4223 
    if mtype == TMessageType.EXCEPTION:
4224 
      x = TApplicationException()
4225 
      x.read(self._iprot)
4226 
      self._iprot.readMessageEnd()
4227 
      raise x
4228 
    result = markOrdersAsReversalInitiated_result()
4229 
    result.read(self._iprot)
4230 
    self._iprot.readMessageEnd()
4231 
    if result.ex is not None:
4232 
      raise result.ex
4233 
    return
4234 
 
4369 rajveer 4235 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4236 
    """
4237 
    Parameters:
4238 
     - vendorId
4239 
     - itemId
4240 
     - quantity
4241 
     - estimate
4369 rajveer 4242 
     - isReminder
4303 rajveer 4243 
    """
4369 rajveer 4244 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4245 
    self.recv_markOrdersAsNotAvailabke()
4246 
 
4369 rajveer 4247 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4248 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4249 
    args = markOrdersAsNotAvailabke_args()
4250 
    args.vendorId = vendorId
4251 
    args.itemId = itemId
4252 
    args.quantity = quantity
4253 
    args.estimate = estimate
4369 rajveer 4254 
    args.isReminder = isReminder
4303 rajveer 4255 
    args.write(self._oprot)
4256 
    self._oprot.writeMessageEnd()
4257 
    self._oprot.trans.flush()
4258 
 
4259 
  def recv_markOrdersAsNotAvailabke(self, ):
4260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4261 
    if mtype == TMessageType.EXCEPTION:
4262 
      x = TApplicationException()
4263 
      x.read(self._iprot)
4264 
      self._iprot.readMessageEnd()
4265 
      raise x
4266 
    result = markOrdersAsNotAvailabke_result()
4267 
    result.read(self._iprot)
4268 
    self._iprot.readMessageEnd()
4269 
    if result.ex is not None:
4270 
      raise result.ex
4271 
    return
4272 
 
4369 rajveer 4273 
  def markOrdersAsTimeout(self, vendorId):
4274 
    """
4275 
    Parameters:
4276 
     - vendorId
4277 
    """
4278 
    self.send_markOrdersAsTimeout(vendorId)
4279 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4280 
 
4369 rajveer 4281 
  def send_markOrdersAsTimeout(self, vendorId):
4282 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4283 
    args = markOrdersAsTimeout_args()
4284 
    args.vendorId = vendorId
4285 
    args.write(self._oprot)
4286 
    self._oprot.writeMessageEnd()
4287 
    self._oprot.trans.flush()
4288 
 
4289 
  def recv_markOrdersAsTimeout(self, ):
4290 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4291 
    if mtype == TMessageType.EXCEPTION:
4292 
      x = TApplicationException()
4293 
      x.read(self._iprot)
4294 
      self._iprot.readMessageEnd()
4295 
      raise x
4296 
    result = markOrdersAsTimeout_result()
4297 
    result.read(self._iprot)
4298 
    self._iprot.readMessageEnd()
4299 
    if result.success is not None:
4300 
      return result.success
4301 
    if result.ex is not None:
4302 
      raise result.ex
4303 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4304 
 
4662 rajveer 4305 
  def markOrderAsLostInTransit(self, orderId):
4306 
    """
4307 
    Mark order as LOST_IN_TRANSIT
4308 
 
4309 
    Parameters:
4310 
     - orderId
4311 
    """
4312 
    self.send_markOrderAsLostInTransit(orderId)
4313 
    return self.recv_markOrderAsLostInTransit()
4314 
 
4315 
  def send_markOrderAsLostInTransit(self, orderId):
4316 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4317 
    args = markOrderAsLostInTransit_args()
4318 
    args.orderId = orderId
4319 
    args.write(self._oprot)
4320 
    self._oprot.writeMessageEnd()
4321 
    self._oprot.trans.flush()
4322 
 
4323 
  def recv_markOrderAsLostInTransit(self, ):
4324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4325 
    if mtype == TMessageType.EXCEPTION:
4326 
      x = TApplicationException()
4327 
      x.read(self._iprot)
4328 
      self._iprot.readMessageEnd()
4329 
      raise x
4330 
    result = markOrderAsLostInTransit_result()
4331 
    result.read(self._iprot)
4332 
    self._iprot.readMessageEnd()
4333 
    if result.success is not None:
4334 
      return result.success
4335 
    if result.ex is not None:
4336 
      raise result.ex
4337 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4338 
 
4386 anupam.sin 4339 
  def getOrderForAwb(self, awb):
4340 
    """
4341 
    Returns the order corresponding to an AWB number
4369 rajveer 4342 
 
4386 anupam.sin 4343 
    Parameters:
4344 
     - awb
4345 
    """
4346 
    self.send_getOrderForAwb(awb)
4347 
    return self.recv_getOrderForAwb()
4348 
 
4349 
  def send_getOrderForAwb(self, awb):
4350 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4351 
    args = getOrderForAwb_args()
4352 
    args.awb = awb
4353 
    args.write(self._oprot)
4354 
    self._oprot.writeMessageEnd()
4355 
    self._oprot.trans.flush()
4356 
 
4357 
  def recv_getOrderForAwb(self, ):
4358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4359 
    if mtype == TMessageType.EXCEPTION:
4360 
      x = TApplicationException()
4361 
      x.read(self._iprot)
4362 
      self._iprot.readMessageEnd()
4363 
      raise x
4364 
    result = getOrderForAwb_result()
4365 
    result.read(self._iprot)
4366 
    self._iprot.readMessageEnd()
4367 
    if result.success is not None:
4368 
      return result.success
4369 
    if result.ex is not None:
4370 
      raise result.ex
4371 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4372 
 
4910 phani.kuma 4373 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4374 
    """
4910 phani.kuma 4375 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4376 
 
4506 phani.kuma 4377 
    Parameters:
4378 
     - logistics_provider_id
4910 phani.kuma 4379 
     - order_status_list
4506 phani.kuma 4380 
    """
4910 phani.kuma 4381 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4382 
    return self.recv_getOrdersForProviderForStatus()
4383 
 
4910 phani.kuma 4384 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4385 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4386 
    args = getOrdersForProviderForStatus_args()
4387 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4388 
    args.order_status_list = order_status_list
4506 phani.kuma 4389 
    args.write(self._oprot)
4390 
    self._oprot.writeMessageEnd()
4391 
    self._oprot.trans.flush()
4392 
 
4393 
  def recv_getOrdersForProviderForStatus(self, ):
4394 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4395 
    if mtype == TMessageType.EXCEPTION:
4396 
      x = TApplicationException()
4397 
      x.read(self._iprot)
4398 
      self._iprot.readMessageEnd()
4399 
      raise x
4400 
    result = getOrdersForProviderForStatus_result()
4401 
    result.read(self._iprot)
4402 
    self._iprot.readMessageEnd()
4403 
    if result.success is not None:
4404 
      return result.success
4405 
    if result.ex is not None:
4406 
      raise result.ex
4407 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4408 
 
4600 varun.gupt 4409 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4410 
    """
4411 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4412 
 
4600 varun.gupt 4413 
    Parameters:
4414 
     - vendorId
4415 
     - billingDateFrom
4416 
     - billingDateTo
4417 
    """
4418 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4419 
    return self.recv_getBilledOrdersForVendor()
4420 
 
4421 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4422 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4423 
    args = getBilledOrdersForVendor_args()
4424 
    args.vendorId = vendorId
4425 
    args.billingDateFrom = billingDateFrom
4426 
    args.billingDateTo = billingDateTo
4427 
    args.write(self._oprot)
4428 
    self._oprot.writeMessageEnd()
4429 
    self._oprot.trans.flush()
4430 
 
4431 
  def recv_getBilledOrdersForVendor(self, ):
4432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4433 
    if mtype == TMessageType.EXCEPTION:
4434 
      x = TApplicationException()
4435 
      x.read(self._iprot)
4436 
      self._iprot.readMessageEnd()
4437 
      raise x
4438 
    result = getBilledOrdersForVendor_result()
4439 
    result.read(self._iprot)
4440 
    self._iprot.readMessageEnd()
4441 
    if result.success is not None:
4442 
      return result.success
4443 
    if result.ex is not None:
4444 
      raise result.ex
4445 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4446 
 
4607 rajveer 4447 
  def getSlippedSippingDateOrders(self, ):
4448 
    self.send_getSlippedSippingDateOrders()
4449 
    return self.recv_getSlippedSippingDateOrders()
4450 
 
4451 
  def send_getSlippedSippingDateOrders(self, ):
4452 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4453 
    args = getSlippedSippingDateOrders_args()
4454 
    args.write(self._oprot)
4455 
    self._oprot.writeMessageEnd()
4456 
    self._oprot.trans.flush()
4457 
 
4458 
  def recv_getSlippedSippingDateOrders(self, ):
4459 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4460 
    if mtype == TMessageType.EXCEPTION:
4461 
      x = TApplicationException()
4462 
      x.read(self._iprot)
4463 
      self._iprot.readMessageEnd()
4464 
      raise x
4465 
    result = getSlippedSippingDateOrders_result()
4466 
    result.read(self._iprot)
4467 
    self._iprot.readMessageEnd()
4468 
    if result.success is not None:
4469 
      return result.success
4470 
    if result.ex is not None:
4471 
      raise result.ex
4472 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4473 
 
4709 rajveer 4474 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4475 
    """
4476 
    Parameters:
4477 
     - cancelDateFrom
4478 
     - cancelDateTo
4479 
    """
4480 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4481 
    return self.recv_getCancelledOrders()
4482 
 
4483 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4484 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4485 
    args = getCancelledOrders_args()
4486 
    args.cancelDateFrom = cancelDateFrom
4487 
    args.cancelDateTo = cancelDateTo
4488 
    args.write(self._oprot)
4489 
    self._oprot.writeMessageEnd()
4490 
    self._oprot.trans.flush()
4491 
 
4492 
  def recv_getCancelledOrders(self, ):
4493 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4494 
    if mtype == TMessageType.EXCEPTION:
4495 
      x = TApplicationException()
4496 
      x.read(self._iprot)
4497 
      self._iprot.readMessageEnd()
4498 
      raise x
4499 
    result = getCancelledOrders_result()
4500 
    result.read(self._iprot)
4501 
    self._iprot.readMessageEnd()
4502 
    if result.success is not None:
4503 
      return result.success
4504 
    if result.ex is not None:
4505 
      raise result.ex
4506 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4507 
 
4600 varun.gupt 4508 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4509 
    """
4510 
    Parameters:
4511 
     - mapAWBAndAmount
4512 
    """
4513 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4514 
    self.recv_saveBluedartSettlements()
4515 
 
4516 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4517 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4518 
    args = saveBluedartSettlements_args()
4519 
    args.mapAWBAndAmount = mapAWBAndAmount
4520 
    args.write(self._oprot)
4521 
    self._oprot.writeMessageEnd()
4522 
    self._oprot.trans.flush()
4523 
 
4524 
  def recv_saveBluedartSettlements(self, ):
4525 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4526 
    if mtype == TMessageType.EXCEPTION:
4527 
      x = TApplicationException()
4528 
      x.read(self._iprot)
4529 
      self._iprot.readMessageEnd()
4530 
      raise x
4531 
    result = saveBluedartSettlements_result()
4532 
    result.read(self._iprot)
4533 
    self._iprot.readMessageEnd()
4534 
    if result.ex is not None:
4535 
      raise result.ex
4536 
    return
4537 
 
4905 varun.gupt 4538 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4539 
    """
4540 
    Parameters:
4541 
     - settlementDate
4542 
     - paymentGatewayId
4905 varun.gupt 4543 
     - referenceId
4600 varun.gupt 4544 
     - serviceTax
4545 
     - otherCharges
4546 
     - netCollection
4547 
    """
4905 varun.gupt 4548 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4549 
    self.recv_savePaymentSettlements()
4550 
 
4905 varun.gupt 4551 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4552 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4553 
    args = savePaymentSettlements_args()
4554 
    args.settlementDate = settlementDate
4555 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4556 
    args.referenceId = referenceId
4600 varun.gupt 4557 
    args.serviceTax = serviceTax
4558 
    args.otherCharges = otherCharges
4559 
    args.netCollection = netCollection
4560 
    args.write(self._oprot)
4561 
    self._oprot.writeMessageEnd()
4562 
    self._oprot.trans.flush()
4563 
 
4564 
  def recv_savePaymentSettlements(self, ):
4565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4566 
    if mtype == TMessageType.EXCEPTION:
4567 
      x = TApplicationException()
4568 
      x.read(self._iprot)
4569 
      self._iprot.readMessageEnd()
4570 
      raise x
4571 
    result = savePaymentSettlements_result()
4572 
    result.read(self._iprot)
4573 
    self._iprot.readMessageEnd()
4574 
    if result.ex is not None:
4575 
      raise result.ex
4576 
    return
4577 
 
4578 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4579 
    """
4580 
    Parameters:
4581 
     - settlementId
4582 
     - settlementDate
4583 
     - transactionDateFrom
4584 
     - transactionDateTo
4585 
     - amount
4586 
    """
4587 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4588 
    self.recv_saveEBSSettlementSummary()
4589 
 
4590 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4591 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4592 
    args = saveEBSSettlementSummary_args()
4593 
    args.settlementId = settlementId
4594 
    args.settlementDate = settlementDate
4595 
    args.transactionDateFrom = transactionDateFrom
4596 
    args.transactionDateTo = transactionDateTo
4597 
    args.amount = amount
4598 
    args.write(self._oprot)
4599 
    self._oprot.writeMessageEnd()
4600 
    self._oprot.trans.flush()
4601 
 
4602 
  def recv_saveEBSSettlementSummary(self, ):
4603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4604 
    if mtype == TMessageType.EXCEPTION:
4605 
      x = TApplicationException()
4606 
      x.read(self._iprot)
4607 
      self._iprot.readMessageEnd()
4608 
      raise x
4609 
    result = saveEBSSettlementSummary_result()
4610 
    result.read(self._iprot)
4611 
    self._iprot.readMessageEnd()
4612 
    if result.ex is not None:
4613 
      raise result.ex
4614 
    return
4615 
 
5189 varun.gupt 4616 
  def getSettlementForReferenceId(self, referenceId, isRefund):
4600 varun.gupt 4617 
    """
4618 
    Parameters:
5189 varun.gupt 4619 
     - referenceId
4620 
     - isRefund
4600 varun.gupt 4621 
    """
5189 varun.gupt 4622 
    self.send_getSettlementForReferenceId(referenceId, isRefund)
4623 
    return self.recv_getSettlementForReferenceId()
4600 varun.gupt 4624 
 
5189 varun.gupt 4625 
  def send_getSettlementForReferenceId(self, referenceId, isRefund):
4626 
    self._oprot.writeMessageBegin('getSettlementForReferenceId', TMessageType.CALL, self._seqid)
4627 
    args = getSettlementForReferenceId_args()
4628 
    args.referenceId = referenceId
4629 
    args.isRefund = isRefund
4600 varun.gupt 4630 
    args.write(self._oprot)
4631 
    self._oprot.writeMessageEnd()
4632 
    self._oprot.trans.flush()
4633 
 
5189 varun.gupt 4634 
  def recv_getSettlementForReferenceId(self, ):
4600 varun.gupt 4635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4636 
    if mtype == TMessageType.EXCEPTION:
4637 
      x = TApplicationException()
4638 
      x.read(self._iprot)
4639 
      self._iprot.readMessageEnd()
4640 
      raise x
5189 varun.gupt 4641 
    result = getSettlementForReferenceId_result()
4600 varun.gupt 4642 
    result.read(self._iprot)
4643 
    self._iprot.readMessageEnd()
4644 
    if result.success is not None:
4645 
      return result.success
4646 
    if result.ex is not None:
4647 
      raise result.ex
5189 varun.gupt 4648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForReferenceId failed: unknown result");
4600 varun.gupt 4649 
 
4650 
  def getEBSSettlementSummaries(self, ):
4651 
    self.send_getEBSSettlementSummaries()
4652 
    return self.recv_getEBSSettlementSummaries()
4653 
 
4654 
  def send_getEBSSettlementSummaries(self, ):
4655 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4656 
    args = getEBSSettlementSummaries_args()
4657 
    args.write(self._oprot)
4658 
    self._oprot.writeMessageEnd()
4659 
    self._oprot.trans.flush()
4660 
 
4661 
  def recv_getEBSSettlementSummaries(self, ):
4662 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4663 
    if mtype == TMessageType.EXCEPTION:
4664 
      x = TApplicationException()
4665 
      x.read(self._iprot)
4666 
      self._iprot.readMessageEnd()
4667 
      raise x
4668 
    result = getEBSSettlementSummaries_result()
4669 
    result.read(self._iprot)
4670 
    self._iprot.readMessageEnd()
4671 
    if result.success is not None:
4672 
      return result.success
4673 
    if result.ex is not None:
4674 
      raise result.ex
4675 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4676 
 
4677 
  def markEBSSettlementUploaded(self, settlementId):
4678 
    """
4679 
    Parameters:
4680 
     - settlementId
4681 
    """
4682 
    self.send_markEBSSettlementUploaded(settlementId)
4683 
    self.recv_markEBSSettlementUploaded()
4684 
 
4685 
  def send_markEBSSettlementUploaded(self, settlementId):
4686 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4687 
    args = markEBSSettlementUploaded_args()
4688 
    args.settlementId = settlementId
4689 
    args.write(self._oprot)
4690 
    self._oprot.writeMessageEnd()
4691 
    self._oprot.trans.flush()
4692 
 
4693 
  def recv_markEBSSettlementUploaded(self, ):
4694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4695 
    if mtype == TMessageType.EXCEPTION:
4696 
      x = TApplicationException()
4697 
      x.read(self._iprot)
4698 
      self._iprot.readMessageEnd()
4699 
      raise x
4700 
    result = markEBSSettlementUploaded_result()
4701 
    result.read(self._iprot)
4702 
    self._iprot.readMessageEnd()
4703 
    if result.ex is not None:
4704 
      raise result.ex
4705 
    return
4706 
 
4707 
  def getEBSSettlementDate(self, settlementId):
4708 
    """
4709 
    Parameters:
4710 
     - settlementId
4711 
    """
4712 
    self.send_getEBSSettlementDate(settlementId)
4713 
    return self.recv_getEBSSettlementDate()
4714 
 
4715 
  def send_getEBSSettlementDate(self, settlementId):
4716 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4717 
    args = getEBSSettlementDate_args()
4718 
    args.settlementId = settlementId
4719 
    args.write(self._oprot)
4720 
    self._oprot.writeMessageEnd()
4721 
    self._oprot.trans.flush()
4722 
 
4723 
  def recv_getEBSSettlementDate(self, ):
4724 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4725 
    if mtype == TMessageType.EXCEPTION:
4726 
      x = TApplicationException()
4727 
      x.read(self._iprot)
4728 
      self._iprot.readMessageEnd()
4729 
      raise x
4730 
    result = getEBSSettlementDate_result()
4731 
    result.read(self._iprot)
4732 
    self._iprot.readMessageEnd()
4733 
    if result.success is not None:
4734 
      return result.success
4735 
    if result.ex is not None:
4736 
      raise result.ex
4737 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4738 
 
4715 varun.gupt 4739 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4740 
    """
4741 
    Parameters:
4742 
     - settlementDateFrom
4743 
     - settlementDateTo
4744 
     - isRefund
4745 
    """
4746 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4747 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4748 
 
4715 varun.gupt 4749 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4750 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4751 
    args = getSettlementsByDate_args()
4752 
    args.settlementDateFrom = settlementDateFrom
4753 
    args.settlementDateTo = settlementDateTo
4754 
    args.isRefund = isRefund
4755 
    args.write(self._oprot)
4756 
    self._oprot.writeMessageEnd()
4757 
    self._oprot.trans.flush()
4758 
 
4759 
  def recv_getSettlementsByDate(self, ):
4760 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4761 
    if mtype == TMessageType.EXCEPTION:
4762 
      x = TApplicationException()
4763 
      x.read(self._iprot)
4764 
      self._iprot.readMessageEnd()
4765 
      raise x
4766 
    result = getSettlementsByDate_result()
4767 
    result.read(self._iprot)
4768 
    self._iprot.readMessageEnd()
4769 
    if result.success is not None:
4770 
      return result.success
4771 
    if result.ex is not None:
4772 
      raise result.ex
4773 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4774 
 
4775 
  def getReshippedOrderIds(self, orderIds):
4776 
    """
4777 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4778 
 
4779 
    Parameters:
4780 
     - orderIds
4781 
    """
4782 
    self.send_getReshippedOrderIds(orderIds)
4783 
    return self.recv_getReshippedOrderIds()
4784 
 
4785 
  def send_getReshippedOrderIds(self, orderIds):
4786 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4787 
    args = getReshippedOrderIds_args()
4788 
    args.orderIds = orderIds
4789 
    args.write(self._oprot)
4790 
    self._oprot.writeMessageEnd()
4791 
    self._oprot.trans.flush()
4792 
 
4793 
  def recv_getReshippedOrderIds(self, ):
4794 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4795 
    if mtype == TMessageType.EXCEPTION:
4796 
      x = TApplicationException()
4797 
      x.read(self._iprot)
4798 
      self._iprot.readMessageEnd()
4799 
      raise x
4800 
    result = getReshippedOrderIds_result()
4801 
    result.read(self._iprot)
4802 
    self._iprot.readMessageEnd()
4803 
    if result.success is not None:
4804 
      return result.success
4805 
    if result.ex is not None:
4806 
      raise result.ex
4807 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4808 
 
4757 mandeep.dh 4809 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4810 
    """
4811 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
4812 
    the quantities for which the PO is raised.
4715 varun.gupt 4813 
 
4757 mandeep.dh 4814 
    Parameters:
4815 
     - itemIdQuantityMap
4816 
     - purchaseOrderId
4817 
     - warehouseId
4818 
    """
4819 
    self.send_updateOrdersAsPORaised(itemIdQuantityMap, purchaseOrderId, warehouseId)
4820 
    self.recv_updateOrdersAsPORaised()
4821 
 
4822 
  def send_updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4823 
    self._oprot.writeMessageBegin('updateOrdersAsPORaised', TMessageType.CALL, self._seqid)
4824 
    args = updateOrdersAsPORaised_args()
4825 
    args.itemIdQuantityMap = itemIdQuantityMap
4826 
    args.purchaseOrderId = purchaseOrderId
4827 
    args.warehouseId = warehouseId
4828 
    args.write(self._oprot)
4829 
    self._oprot.writeMessageEnd()
4830 
    self._oprot.trans.flush()
4831 
 
4832 
  def recv_updateOrdersAsPORaised(self, ):
4833 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4834 
    if mtype == TMessageType.EXCEPTION:
4835 
      x = TApplicationException()
4836 
      x.read(self._iprot)
4837 
      self._iprot.readMessageEnd()
4838 
      raise x
4839 
    result = updateOrdersAsPORaised_result()
4840 
    result.read(self._iprot)
4841 
    self._iprot.readMessageEnd()
4842 
    if result.ex is not None:
4843 
      raise result.ex
4844 
    return
4845 
 
4875 varun.gupt 4846 
  def getOrdersWhereVendorNotPaid(self, vendorId):
4847 
    """
4848 
    Parameters:
4849 
     - vendorId
4850 
    """
4851 
    self.send_getOrdersWhereVendorNotPaid(vendorId)
4852 
    return self.recv_getOrdersWhereVendorNotPaid()
4757 mandeep.dh 4853 
 
4875 varun.gupt 4854 
  def send_getOrdersWhereVendorNotPaid(self, vendorId):
4855 
    self._oprot.writeMessageBegin('getOrdersWhereVendorNotPaid', TMessageType.CALL, self._seqid)
4856 
    args = getOrdersWhereVendorNotPaid_args()
4857 
    args.vendorId = vendorId
4858 
    args.write(self._oprot)
4859 
    self._oprot.writeMessageEnd()
4860 
    self._oprot.trans.flush()
4861 
 
4862 
  def recv_getOrdersWhereVendorNotPaid(self, ):
4863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4864 
    if mtype == TMessageType.EXCEPTION:
4865 
      x = TApplicationException()
4866 
      x.read(self._iprot)
4867 
      self._iprot.readMessageEnd()
4868 
      raise x
4869 
    result = getOrdersWhereVendorNotPaid_result()
4870 
    result.read(self._iprot)
4871 
    self._iprot.readMessageEnd()
4872 
    if result.success is not None:
4873 
      return result.success
4874 
    if result.ex is not None:
4875 
      raise result.ex
4876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersWhereVendorNotPaid failed: unknown result");
4877 
 
5031 varun.gupt 4878 
  def getStatusDistributionOfOrders(self, startDate, endDate):
4879 
    """
4880 
    Parameters:
4881 
     - startDate
4882 
     - endDate
4883 
    """
4884 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
4885 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 4886 
 
5031 varun.gupt 4887 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
4888 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
4889 
    args = getStatusDistributionOfOrders_args()
4890 
    args.startDate = startDate
4891 
    args.endDate = endDate
4892 
    args.write(self._oprot)
4893 
    self._oprot.writeMessageEnd()
4894 
    self._oprot.trans.flush()
4895 
 
4896 
  def recv_getStatusDistributionOfOrders(self, ):
4897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4898 
    if mtype == TMessageType.EXCEPTION:
4899 
      x = TApplicationException()
4900 
      x.read(self._iprot)
4901 
      self._iprot.readMessageEnd()
4902 
      raise x
4903 
    result = getStatusDistributionOfOrders_result()
4904 
    result.read(self._iprot)
4905 
    self._iprot.readMessageEnd()
4906 
    if result.success is not None:
4907 
      return result.success
4908 
    if result.ex is not None:
4909 
      raise result.ex
4910 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
4911 
 
5067 varun.gupt 4912 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
4913 
    """
4914 
    Parameters:
4915 
     - status
4916 
     - startDatetime
4917 
     - endDatetime
4918 
    """
4919 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
4920 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 4921 
 
5067 varun.gupt 4922 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
4923 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
4924 
    args = getOrderIdsForStatus_args()
4925 
    args.status = status
4926 
    args.startDatetime = startDatetime
4927 
    args.endDatetime = endDatetime
4928 
    args.write(self._oprot)
4929 
    self._oprot.writeMessageEnd()
4930 
    self._oprot.trans.flush()
4931 
 
4932 
  def recv_getOrderIdsForStatus(self, ):
4933 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4934 
    if mtype == TMessageType.EXCEPTION:
4935 
      x = TApplicationException()
4936 
      x.read(self._iprot)
4937 
      self._iprot.readMessageEnd()
4938 
      raise x
4939 
    result = getOrderIdsForStatus_result()
4940 
    result.read(self._iprot)
4941 
    self._iprot.readMessageEnd()
4942 
    if result.success is not None:
4943 
      return result.success
4944 
    if result.ex is not None:
4945 
      raise result.ex
4946 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
4947 
 
5099 varun.gupt 4948 
  def updateOrderAsPaidToVendor(self, orderId):
4949 
    """
4950 
    Parameters:
4951 
     - orderId
4952 
    """
4953 
    self.send_updateOrderAsPaidToVendor(orderId)
4954 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 4955 
 
5099 varun.gupt 4956 
  def send_updateOrderAsPaidToVendor(self, orderId):
4957 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
4958 
    args = updateOrderAsPaidToVendor_args()
4959 
    args.orderId = orderId
4960 
    args.write(self._oprot)
4961 
    self._oprot.writeMessageEnd()
4962 
    self._oprot.trans.flush()
4963 
 
4964 
  def recv_updateOrderAsPaidToVendor(self, ):
4965 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4966 
    if mtype == TMessageType.EXCEPTION:
4967 
      x = TApplicationException()
4968 
      x.read(self._iprot)
4969 
      self._iprot.readMessageEnd()
4970 
      raise x
4971 
    result = updateOrderAsPaidToVendor_result()
4972 
    result.read(self._iprot)
4973 
    self._iprot.readMessageEnd()
4974 
    if result.ex is not None:
4975 
      raise result.ex
4976 
    return
4977 
 
4978 
 
3376 rajveer 4979 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 4980 
  def __init__(self, handler):
3376 rajveer 4981 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 4982 
    self._processMap["createTransaction"] = Processor.process_createTransaction
4983 
    self._processMap["getTransaction"] = Processor.process_getTransaction
4984 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 4985 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 4986 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
4987 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 4988 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 4989 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 4990 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
4991 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 4992 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 4993 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 4994 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
4995 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 4996 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
4997 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
4998 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
4999 
    self._processMap["createOrder"] = Processor.process_createOrder
5000 
    self._processMap["getOrder"] = Processor.process_getOrder
5001 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 5002 
    self._processMap["getOrderList"] = Processor.process_getOrderList
1528 ankur.sing 5003 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 5004 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 5005 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 5006 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 5007 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
5008 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
5009 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
5010 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 5011 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 5012 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 5013 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
5014 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
5015 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 5016 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 5017 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 5018 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 5019 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 5020 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 5021 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
5022 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 5023 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 5024 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
5025 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
5026 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
5027 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
5028 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 5029 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 5030 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 5031 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 5032 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 5033 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
5034 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 5035 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
5036 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 5037 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
5038 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 5039 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 5040 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 5041 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 5042 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 5043 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 5044 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 5045 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 5046 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
5047 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 5048 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 5049 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 5050 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 5051 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 5052 
    self._processMap["changeItem"] = Processor.process_changeItem
5053 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 5054 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 5055 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 5056 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
5057 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 5058 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 5059 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 5060 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
5061 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
5062 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 5063 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 5064 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 5065 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 5066 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 5067 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
5068 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
5069 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 5070 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 5071 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 5072 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 5073 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 5074 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 5075 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 5076 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 5077 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
5078 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
5079 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5189 varun.gupt 5080 
    self._processMap["getSettlementForReferenceId"] = Processor.process_getSettlementForReferenceId
4600 varun.gupt 5081 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
5082 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
5083 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 5084 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
5085 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
4757 mandeep.dh 5086 
    self._processMap["updateOrdersAsPORaised"] = Processor.process_updateOrdersAsPORaised
4875 varun.gupt 5087 
    self._processMap["getOrdersWhereVendorNotPaid"] = Processor.process_getOrdersWhereVendorNotPaid
5031 varun.gupt 5088 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 5089 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5099 varun.gupt 5090 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
94 ashish 5091 
 
5092 
  def process(self, iprot, oprot):
5093 
    (name, type, seqid) = iprot.readMessageBegin()
5094 
    if name not in self._processMap:
5095 
      iprot.skip(TType.STRUCT)
5096 
      iprot.readMessageEnd()
5097 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5098 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5099 
      x.write(oprot)
5100 
      oprot.writeMessageEnd()
5101 
      oprot.trans.flush()
5102 
      return
5103 
    else:
5104 
      self._processMap[name](self, seqid, iprot, oprot)
5105 
    return True
5106 
 
5107 
  def process_createTransaction(self, seqid, iprot, oprot):
5108 
    args = createTransaction_args()
5109 
    args.read(iprot)
5110 
    iprot.readMessageEnd()
5111 
    result = createTransaction_result()
5112 
    try:
132 ashish 5113 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 5114 
    except TransactionServiceException, ex:
5115 
      result.ex = ex
5116 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
5117 
    result.write(oprot)
5118 
    oprot.writeMessageEnd()
5119 
    oprot.trans.flush()
5120 
 
5121 
  def process_getTransaction(self, seqid, iprot, oprot):
5122 
    args = getTransaction_args()
5123 
    args.read(iprot)
5124 
    iprot.readMessageEnd()
5125 
    result = getTransaction_result()
5126 
    try:
5127 
      result.success = self._handler.getTransaction(args.id)
5128 
    except TransactionServiceException, ex:
5129 
      result.ex = ex
5130 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
5131 
    result.write(oprot)
5132 
    oprot.writeMessageEnd()
5133 
    oprot.trans.flush()
5134 
 
5135 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
5136 
    args = getTransactionsForCustomer_args()
5137 
    args.read(iprot)
5138 
    iprot.readMessageEnd()
5139 
    result = getTransactionsForCustomer_result()
5140 
    try:
5141 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
5142 
    except TransactionServiceException, ex:
5143 
      result.ex = ex
5144 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
5145 
    result.write(oprot)
5146 
    oprot.writeMessageEnd()
5147 
    oprot.trans.flush()
5148 
 
132 ashish 5149 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
5150 
    args = getTransactionsForShoppingCartId_args()
5151 
    args.read(iprot)
5152 
    iprot.readMessageEnd()
5153 
    result = getTransactionsForShoppingCartId_result()
5154 
    try:
5155 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
5156 
    except TransactionServiceException, ex:
5157 
      result.ex = ex
5158 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
5159 
    result.write(oprot)
5160 
    oprot.writeMessageEnd()
5161 
    oprot.trans.flush()
5162 
 
94 ashish 5163 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
5164 
    args = getTransactionStatus_args()
5165 
    args.read(iprot)
5166 
    iprot.readMessageEnd()
5167 
    result = getTransactionStatus_result()
5168 
    try:
5169 
      result.success = self._handler.getTransactionStatus(args.transactionId)
5170 
    except TransactionServiceException, ex:
5171 
      result.ex = ex
5172 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
5173 
    result.write(oprot)
5174 
    oprot.writeMessageEnd()
5175 
    oprot.trans.flush()
5176 
 
5177 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
5178 
    args = changeTransactionStatus_args()
5179 
    args.read(iprot)
5180 
    iprot.readMessageEnd()
5181 
    result = changeTransactionStatus_result()
5182 
    try:
5183 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
5184 
    except TransactionServiceException, ex:
5185 
      result.ex = ex
5186 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
5187 
    result.write(oprot)
5188 
    oprot.writeMessageEnd()
5189 
    oprot.trans.flush()
5190 
 
1398 varun.gupt 5191 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
5192 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 5193 
    args.read(iprot)
5194 
    iprot.readMessageEnd()
1398 varun.gupt 5195 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 5196 
    try:
1398 varun.gupt 5197 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 5198 
    except TransactionServiceException, ex:
5199 
      result.ex = ex
1398 varun.gupt 5200 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 5201 
    result.write(oprot)
5202 
    oprot.writeMessageEnd()
5203 
    oprot.trans.flush()
5204 
 
483 rajveer 5205 
  def process_getAllOrders(self, seqid, iprot, oprot):
5206 
    args = getAllOrders_args()
94 ashish 5207 
    args.read(iprot)
5208 
    iprot.readMessageEnd()
483 rajveer 5209 
    result = getAllOrders_result()
94 ashish 5210 
    try:
4801 anupam.sin 5211 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 5212 
    except TransactionServiceException, ex:
5213 
      result.ex = ex
483 rajveer 5214 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 5215 
    result.write(oprot)
5216 
    oprot.writeMessageEnd()
5217 
    oprot.trans.flush()
5218 
 
4133 chandransh 5219 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
5220 
    args = getOrdersInBatch_args()
5221 
    args.read(iprot)
5222 
    iprot.readMessageEnd()
5223 
    result = getOrdersInBatch_result()
5224 
    try:
5225 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
5226 
    except TransactionServiceException, ex:
5227 
      result.ex = ex
5228 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
5229 
    result.write(oprot)
5230 
    oprot.writeMessageEnd()
5231 
    oprot.trans.flush()
5232 
 
5233 
  def process_getOrderCount(self, seqid, iprot, oprot):
5234 
    args = getOrderCount_args()
5235 
    args.read(iprot)
5236 
    iprot.readMessageEnd()
5237 
    result = getOrderCount_result()
5238 
    try:
5239 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
5240 
    except TransactionServiceException, ex:
5241 
      result.ex = ex
5242 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
5243 
    result.write(oprot)
5244 
    oprot.writeMessageEnd()
5245 
    oprot.trans.flush()
5246 
 
999 varun.gupt 5247 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
5248 
    args = getOrdersByBillingDate_args()
5249 
    args.read(iprot)
5250 
    iprot.readMessageEnd()
5251 
    result = getOrdersByBillingDate_result()
5252 
    try:
5253 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
5254 
    except TransactionServiceException, ex:
5255 
      result.ex = ex
5256 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
5257 
    result.write(oprot)
5258 
    oprot.writeMessageEnd()
5259 
    oprot.trans.flush()
5260 
 
3427 chandransh 5261 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
5262 
    args = getOrdersByShippingDate_args()
5263 
    args.read(iprot)
5264 
    iprot.readMessageEnd()
5265 
    result = getOrdersByShippingDate_result()
5266 
    try:
3451 chandransh 5267 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 5268 
    except TransactionServiceException, ex:
5269 
      result.ex = ex
5270 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
5271 
    result.write(oprot)
5272 
    oprot.writeMessageEnd()
5273 
    oprot.trans.flush()
5274 
 
1382 varun.gupt 5275 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
5276 
    args = getReturnableOrdersForCustomer_args()
5277 
    args.read(iprot)
5278 
    iprot.readMessageEnd()
5279 
    result = getReturnableOrdersForCustomer_result()
5280 
    try:
5281 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
5282 
    except TransactionServiceException, ex:
5283 
      result.ex = ex
5284 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
5285 
    result.write(oprot)
5286 
    oprot.writeMessageEnd()
5287 
    oprot.trans.flush()
5288 
 
5289 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
5290 
    args = getCancellableOrdersForCustomer_args()
5291 
    args.read(iprot)
5292 
    iprot.readMessageEnd()
5293 
    result = getCancellableOrdersForCustomer_result()
5294 
    try:
5295 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
5296 
    except TransactionServiceException, ex:
5297 
      result.ex = ex
5298 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
5299 
    result.write(oprot)
5300 
    oprot.writeMessageEnd()
5301 
    oprot.trans.flush()
5302 
 
483 rajveer 5303 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
5304 
    args = changeOrderStatus_args()
94 ashish 5305 
    args.read(iprot)
5306 
    iprot.readMessageEnd()
483 rajveer 5307 
    result = changeOrderStatus_result()
94 ashish 5308 
    try:
483 rajveer 5309 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 5310 
    except TransactionServiceException, ex:
5311 
      result.ex = ex
483 rajveer 5312 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 5313 
    result.write(oprot)
5314 
    oprot.writeMessageEnd()
5315 
    oprot.trans.flush()
5316 
 
483 rajveer 5317 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
5318 
    args = getOrdersForTransaction_args()
94 ashish 5319 
    args.read(iprot)
5320 
    iprot.readMessageEnd()
483 rajveer 5321 
    result = getOrdersForTransaction_result()
94 ashish 5322 
    try:
1528 ankur.sing 5323 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 5324 
    except TransactionServiceException, ex:
5325 
      result.ex = ex
483 rajveer 5326 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 5327 
    result.write(oprot)
5328 
    oprot.writeMessageEnd()
5329 
    oprot.trans.flush()
5330 
 
483 rajveer 5331 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
5332 
    args = getOrdersForCustomer_args()
94 ashish 5333 
    args.read(iprot)
5334 
    iprot.readMessageEnd()
483 rajveer 5335 
    result = getOrdersForCustomer_result()
94 ashish 5336 
    try:
3014 chandransh 5337 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 5338 
    except TransactionServiceException, ex:
5339 
      result.ex = ex
483 rajveer 5340 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 5341 
    result.write(oprot)
5342 
    oprot.writeMessageEnd()
5343 
    oprot.trans.flush()
5344 
 
483 rajveer 5345 
  def process_createOrder(self, seqid, iprot, oprot):
5346 
    args = createOrder_args()
94 ashish 5347 
    args.read(iprot)
5348 
    iprot.readMessageEnd()
483 rajveer 5349 
    result = createOrder_result()
94 ashish 5350 
    try:
483 rajveer 5351 
      result.success = self._handler.createOrder(args.order)
94 ashish 5352 
    except TransactionServiceException, ex:
5353 
      result.ex = ex
483 rajveer 5354 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 5355 
    result.write(oprot)
5356 
    oprot.writeMessageEnd()
5357 
    oprot.trans.flush()
5358 
 
483 rajveer 5359 
  def process_getOrder(self, seqid, iprot, oprot):
5360 
    args = getOrder_args()
94 ashish 5361 
    args.read(iprot)
5362 
    iprot.readMessageEnd()
483 rajveer 5363 
    result = getOrder_result()
94 ashish 5364 
    try:
483 rajveer 5365 
      result.success = self._handler.getOrder(args.id)
94 ashish 5366 
    except TransactionServiceException, ex:
5367 
      result.ex = ex
483 rajveer 5368 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 5369 
    result.write(oprot)
5370 
    oprot.writeMessageEnd()
5371 
    oprot.trans.flush()
5372 
 
483 rajveer 5373 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
5374 
    args = getLineItemsForOrder_args()
94 ashish 5375 
    args.read(iprot)
5376 
    iprot.readMessageEnd()
483 rajveer 5377 
    result = getLineItemsForOrder_result()
94 ashish 5378 
    try:
483 rajveer 5379 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 5380 
    except TransactionServiceException, ex:
5381 
      result.ex = ex
483 rajveer 5382 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 5383 
    result.write(oprot)
5384 
    oprot.writeMessageEnd()
5385 
    oprot.trans.flush()
5386 
 
4999 phani.kuma 5387 
  def process_getOrderList(self, seqid, iprot, oprot):
5388 
    args = getOrderList_args()
5389 
    args.read(iprot)
5390 
    iprot.readMessageEnd()
5391 
    result = getOrderList_result()
5392 
    result.success = self._handler.getOrderList(args.order_ids)
5393 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
5394 
    result.write(oprot)
5395 
    oprot.writeMessageEnd()
5396 
    oprot.trans.flush()
5397 
 
1528 ankur.sing 5398 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
5399 
    args = getOrderForCustomer_args()
5400 
    args.read(iprot)
5401 
    iprot.readMessageEnd()
5402 
    result = getOrderForCustomer_result()
5403 
    try:
5404 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
5405 
    except TransactionServiceException, ex:
5406 
      result.ex = ex
5407 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
5408 
    result.write(oprot)
5409 
    oprot.writeMessageEnd()
5410 
    oprot.trans.flush()
5411 
 
3064 chandransh 5412 
  def process_getAlerts(self, seqid, iprot, oprot):
5413 
    args = getAlerts_args()
5414 
    args.read(iprot)
5415 
    iprot.readMessageEnd()
5416 
    result = getAlerts_result()
4444 rajveer 5417 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 5418 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
5419 
    result.write(oprot)
5420 
    oprot.writeMessageEnd()
5421 
    oprot.trans.flush()
5422 
 
4394 rajveer 5423 
  def process_addAlert(self, seqid, iprot, oprot):
5424 
    args = addAlert_args()
3064 chandransh 5425 
    args.read(iprot)
5426 
    iprot.readMessageEnd()
4394 rajveer 5427 
    result = addAlert_result()
4444 rajveer 5428 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 5429 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 5430 
    result.write(oprot)
5431 
    oprot.writeMessageEnd()
5432 
    oprot.trans.flush()
5433 
 
4444 rajveer 5434 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
5435 
    args = markAlertsAsSeen_args()
5436 
    args.read(iprot)
5437 
    iprot.readMessageEnd()
5438 
    result = markAlertsAsSeen_result()
5439 
    self._handler.markAlertsAsSeen(args.warehouseId)
5440 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
5441 
    result.write(oprot)
5442 
    oprot.writeMessageEnd()
5443 
    oprot.trans.flush()
5444 
 
3064 chandransh 5445 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
5446 
    args = getValidOrderCount_args()
5447 
    args.read(iprot)
5448 
    iprot.readMessageEnd()
5449 
    result = getValidOrderCount_result()
5450 
    result.success = self._handler.getValidOrderCount()
5451 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
5452 
    result.write(oprot)
5453 
    oprot.writeMessageEnd()
5454 
    oprot.trans.flush()
5455 
 
5456 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
5457 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
5458 
    args.read(iprot)
5459 
    iprot.readMessageEnd()
5460 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
5461 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
5462 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
5463 
    result.write(oprot)
5464 
    oprot.writeMessageEnd()
5465 
    oprot.trans.flush()
5466 
 
5467 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
5468 
    args = getValidOrdersAmountRange_args()
5469 
    args.read(iprot)
5470 
    iprot.readMessageEnd()
5471 
    result = getValidOrdersAmountRange_result()
5472 
    result.success = self._handler.getValidOrdersAmountRange()
5473 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
5474 
    result.write(oprot)
5475 
    oprot.writeMessageEnd()
5476 
    oprot.trans.flush()
5477 
 
5478 
  def process_getValidOrders(self, seqid, iprot, oprot):
5479 
    args = getValidOrders_args()
5480 
    args.read(iprot)
5481 
    iprot.readMessageEnd()
5482 
    result = getValidOrders_result()
5483 
    result.success = self._handler.getValidOrders(args.limit)
5484 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
5485 
    result.write(oprot)
5486 
    oprot.writeMessageEnd()
5487 
    oprot.trans.flush()
5488 
 
1220 chandransh 5489 
  def process_batchOrders(self, seqid, iprot, oprot):
5490 
    args = batchOrders_args()
5491 
    args.read(iprot)
5492 
    iprot.readMessageEnd()
5493 
    result = batchOrders_result()
5494 
    try:
5495 
      result.success = self._handler.batchOrders(args.warehouseId)
5496 
    except TransactionServiceException, ex:
5497 
      result.ex = ex
5498 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
5499 
    result.write(oprot)
5500 
    oprot.writeMessageEnd()
5501 
    oprot.trans.flush()
5502 
 
1208 chandransh 5503 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
5504 
    args = markOrderAsOutOfStock_args()
5505 
    args.read(iprot)
5506 
    iprot.readMessageEnd()
5507 
    result = markOrderAsOutOfStock_result()
5508 
    try:
5509 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
5510 
    except TransactionServiceException, ex:
5511 
      result.ex = ex
5512 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
5513 
    result.write(oprot)
5514 
    oprot.writeMessageEnd()
5515 
    oprot.trans.flush()
5516 
 
3064 chandransh 5517 
  def process_verifyOrder(self, seqid, iprot, oprot):
5518 
    args = verifyOrder_args()
759 chandransh 5519 
    args.read(iprot)
5520 
    iprot.readMessageEnd()
3064 chandransh 5521 
    result = verifyOrder_result()
759 chandransh 5522 
    try:
3064 chandransh 5523 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 5524 
    except TransactionServiceException, ex:
5525 
      result.ex = ex
3064 chandransh 5526 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 5527 
    result.write(oprot)
5528 
    oprot.writeMessageEnd()
5529 
    oprot.trans.flush()
5530 
 
3064 chandransh 5531 
  def process_acceptOrder(self, seqid, iprot, oprot):
5532 
    args = acceptOrder_args()
1113 chandransh 5533 
    args.read(iprot)
5534 
    iprot.readMessageEnd()
3064 chandransh 5535 
    result = acceptOrder_result()
1113 chandransh 5536 
    try:
3064 chandransh 5537 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 5538 
    except TransactionServiceException, ex:
5539 
      result.ex = ex
3064 chandransh 5540 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 5541 
    result.write(oprot)
5542 
    oprot.writeMessageEnd()
5543 
    oprot.trans.flush()
5544 
 
3064 chandransh 5545 
  def process_addBillingDetails(self, seqid, iprot, oprot):
5546 
    args = addBillingDetails_args()
1135 chandransh 5547 
    args.read(iprot)
5548 
    iprot.readMessageEnd()
3064 chandransh 5549 
    result = addBillingDetails_result()
1135 chandransh 5550 
    try:
5110 mandeep.dh 5551 
      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 5552 
    except TransactionServiceException, ex:
5553 
      result.ex = ex
3064 chandransh 5554 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 5555 
    result.write(oprot)
5556 
    oprot.writeMessageEnd()
5557 
    oprot.trans.flush()
5558 
 
4579 rajveer 5559 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
5560 
    args = addInvoiceNumber_args()
5561 
    args.read(iprot)
5562 
    iprot.readMessageEnd()
5563 
    result = addInvoiceNumber_result()
5564 
    try:
4763 rajveer 5565 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 5566 
    except TransactionServiceException, ex:
5567 
      result.ex = ex
5568 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
5569 
    result.write(oprot)
5570 
    oprot.writeMessageEnd()
5571 
    oprot.trans.flush()
5572 
 
4410 rajveer 5573 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5574 
    args = markOrdersAsShippedFromWarehouse_args()
5575 
    args.read(iprot)
5576 
    iprot.readMessageEnd()
5577 
    result = markOrdersAsShippedFromWarehouse_result()
5578 
    try:
4789 rajveer 5579 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 5580 
    except TransactionServiceException, ex:
5581 
      result.ex = ex
5582 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5583 
    result.write(oprot)
5584 
    oprot.writeMessageEnd()
5585 
    oprot.trans.flush()
5586 
 
3064 chandransh 5587 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5588 
    args = markOrdersAsPickedUp_args()
304 ashish 5589 
    args.read(iprot)
5590 
    iprot.readMessageEnd()
3064 chandransh 5591 
    result = markOrdersAsPickedUp_result()
5592 
    try:
4910 phani.kuma 5593 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 5594 
    except TransactionServiceException, ex:
5595 
      result.ex = ex
5596 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5597 
    result.write(oprot)
5598 
    oprot.writeMessageEnd()
5599 
    oprot.trans.flush()
94 ashish 5600 
 
4910 phani.kuma 5601 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
5602 
    args = getOrdersNotPickedUp_args()
5603 
    args.read(iprot)
5604 
    iprot.readMessageEnd()
5605 
    result = getOrdersNotPickedUp_result()
5606 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
5607 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
5608 
    result.write(oprot)
5609 
    oprot.writeMessageEnd()
5610 
    oprot.trans.flush()
5611 
 
3064 chandransh 5612 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5613 
    args = markOrdersAsDelivered_args()
304 ashish 5614 
    args.read(iprot)
5615 
    iprot.readMessageEnd()
3064 chandransh 5616 
    result = markOrdersAsDelivered_result()
5617 
    try:
5618 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5619 
    except TransactionServiceException, ex:
5620 
      result.ex = ex
5621 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5622 
    result.write(oprot)
5623 
    oprot.writeMessageEnd()
5624 
    oprot.trans.flush()
5625 
 
4910 phani.kuma 5626 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
5627 
    args = markAsRTOrders_args()
1596 ankur.sing 5628 
    args.read(iprot)
5629 
    iprot.readMessageEnd()
4910 phani.kuma 5630 
    result = markAsRTOrders_result()
3064 chandransh 5631 
    try:
4910 phani.kuma 5632 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 5633 
    except TransactionServiceException, ex:
5634 
      result.ex = ex
4910 phani.kuma 5635 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 5636 
    result.write(oprot)
5637 
    oprot.writeMessageEnd()
5638 
    oprot.trans.flush()
304 ashish 5639 
 
4910 phani.kuma 5640 
  def process_getRTOrders(self, seqid, iprot, oprot):
5641 
    args = getRTOrders_args()
5642 
    args.read(iprot)
5643 
    iprot.readMessageEnd()
5644 
    result = getRTOrders_result()
5645 
    result.success = self._handler.getRTOrders(args.providerId)
5646 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
5647 
    result.write(oprot)
5648 
    oprot.writeMessageEnd()
5649 
    oprot.trans.flush()
5650 
 
3064 chandransh 5651 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5652 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5653 
    args.read(iprot)
5654 
    iprot.readMessageEnd()
3064 chandransh 5655 
    result = updateNonDeliveryReason_result()
5656 
    try:
4910 phani.kuma 5657 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5658 
    except TransactionServiceException, ex:
5659 
      result.ex = ex
5660 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5661 
    result.write(oprot)
5662 
    oprot.writeMessageEnd()
5663 
    oprot.trans.flush()
1596 ankur.sing 5664 
 
4910 phani.kuma 5665 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
5666 
    args = getNonDeliveredOrdersbyCourier_args()
5667 
    args.read(iprot)
5668 
    iprot.readMessageEnd()
5669 
    result = getNonDeliveredOrdersbyCourier_result()
5670 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
5671 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
5672 
    result.write(oprot)
5673 
    oprot.writeMessageEnd()
5674 
    oprot.trans.flush()
5675 
 
5676 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
5677 
    args = markOrdersAsLocalConnected_args()
5678 
    args.read(iprot)
5679 
    iprot.readMessageEnd()
5680 
    result = markOrdersAsLocalConnected_result()
5681 
    try:
5682 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
5683 
    except TransactionServiceException, ex:
5684 
      result.ex = ex
5685 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
5686 
    result.write(oprot)
5687 
    oprot.writeMessageEnd()
5688 
    oprot.trans.flush()
5689 
 
5690 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
5691 
    args = getOrdersNotLocalConnected_args()
5692 
    args.read(iprot)
5693 
    iprot.readMessageEnd()
5694 
    result = getOrdersNotLocalConnected_result()
5695 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
5696 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
5697 
    result.write(oprot)
5698 
    oprot.writeMessageEnd()
5699 
    oprot.trans.flush()
5700 
 
5701 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
5702 
    args = markOrdersAsDestinationCityReached_args()
5703 
    args.read(iprot)
5704 
    iprot.readMessageEnd()
5705 
    result = markOrdersAsDestinationCityReached_result()
5706 
    try:
5707 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
5708 
    except TransactionServiceException, ex:
5709 
      result.ex = ex
5710 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
5711 
    result.write(oprot)
5712 
    oprot.writeMessageEnd()
5713 
    oprot.trans.flush()
5714 
 
5715 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
5716 
    args = markOrdersAsFirstDeliveryAttempted_args()
5717 
    args.read(iprot)
5718 
    iprot.readMessageEnd()
5719 
    result = markOrdersAsFirstDeliveryAttempted_result()
5720 
    try:
5721 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
5722 
    except TransactionServiceException, ex:
5723 
      result.ex = ex
5724 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
5725 
    result.write(oprot)
5726 
    oprot.writeMessageEnd()
5727 
    oprot.trans.flush()
5728 
 
3064 chandransh 5729 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5730 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5731 
    args.read(iprot)
5732 
    iprot.readMessageEnd()
3064 chandransh 5733 
    result = getUndeliveredOrders_result()
5734 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5735 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5736 
    result.write(oprot)
5737 
    oprot.writeMessageEnd()
5738 
    oprot.trans.flush()
5739 
 
4783 phani.kuma 5740 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
5741 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
5742 
    args.read(iprot)
5743 
    iprot.readMessageEnd()
5744 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
5745 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
5746 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
5747 
    result.write(oprot)
5748 
    oprot.writeMessageEnd()
5749 
    oprot.trans.flush()
5750 
 
2536 chandransh 5751 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5752 
    args = toggleDOAFlag_args()
5753 
    args.read(iprot)
5754 
    iprot.readMessageEnd()
5755 
    result = toggleDOAFlag_result()
5756 
    try:
5757 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5758 
    except TransactionServiceException, ex:
5759 
      result.ex = ex
5760 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5761 
    result.write(oprot)
5762 
    oprot.writeMessageEnd()
5763 
    oprot.trans.flush()
1886 ankur.sing 5764 
 
4712 rajveer 5765 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5766 
    args = markOrderAsDelivered_args()
5767 
    args.read(iprot)
5768 
    iprot.readMessageEnd()
5769 
    result = markOrderAsDelivered_result()
5770 
    try:
5771 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5772 
    except TransactionServiceException, ex:
5773 
      result.ex = ex
5774 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5775 
    result.write(oprot)
5776 
    oprot.writeMessageEnd()
5777 
    oprot.trans.flush()
5778 
 
4454 rajveer 5779 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5780 
    args = markOrderDoaRequestReceived_args()
5781 
    args.read(iprot)
5782 
    iprot.readMessageEnd()
5783 
    result = markOrderDoaRequestReceived_result()
5784 
    try:
5785 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5786 
    except TransactionServiceException, ex:
5787 
      result.ex = ex
5788 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5789 
    result.write(oprot)
5790 
    oprot.writeMessageEnd()
5791 
    oprot.trans.flush()
5792 
 
5793 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
5794 
    args = markOrderDoaRequestAuthorized_args()
5795 
    args.read(iprot)
5796 
    iprot.readMessageEnd()
5797 
    result = markOrderDoaRequestAuthorized_result()
5798 
    try:
5799 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
5800 
    except TransactionServiceException, ex:
5801 
      result.ex = ex
5802 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
5803 
    result.write(oprot)
5804 
    oprot.writeMessageEnd()
5805 
    oprot.trans.flush()
5806 
 
4488 rajveer 5807 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5808 
    args = markOrderReturnRequestReceived_args()
5809 
    args.read(iprot)
5810 
    iprot.readMessageEnd()
5811 
    result = markOrderReturnRequestReceived_result()
5812 
    try:
5813 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5814 
    except TransactionServiceException, ex:
5815 
      result.ex = ex
5816 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5817 
    result.write(oprot)
5818 
    oprot.writeMessageEnd()
5819 
    oprot.trans.flush()
5820 
 
5821 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5822 
    args = markOrderReturnRequestAuthorized_args()
5823 
    args.read(iprot)
5824 
    iprot.readMessageEnd()
5825 
    result = markOrderReturnRequestAuthorized_result()
5826 
    try:
5827 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5828 
    except TransactionServiceException, ex:
5829 
      result.ex = ex
5830 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5831 
    result.write(oprot)
5832 
    oprot.writeMessageEnd()
5833 
    oprot.trans.flush()
5834 
 
2536 chandransh 5835 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5836 
    args = requestPickupNumber_args()
5837 
    args.read(iprot)
5838 
    iprot.readMessageEnd()
5839 
    result = requestPickupNumber_result()
5840 
    try:
4579 rajveer 5841 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 5842 
    except TransactionServiceException, ex:
5843 
      result.ex = ex
5844 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
5845 
    result.write(oprot)
5846 
    oprot.writeMessageEnd()
5847 
    oprot.trans.flush()
5848 
 
5849 
  def process_authorizePickup(self, seqid, iprot, oprot):
5850 
    args = authorizePickup_args()
5851 
    args.read(iprot)
5852 
    iprot.readMessageEnd()
5853 
    result = authorizePickup_result()
5854 
    try:
4602 rajveer 5855 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 5856 
    except TransactionServiceException, ex:
5857 
      result.ex = ex
5858 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
5859 
    result.write(oprot)
5860 
    oprot.writeMessageEnd()
5861 
    oprot.trans.flush()
5862 
 
2764 chandransh 5863 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
5864 
    args = markDoasAsPickedUp_args()
5865 
    args.read(iprot)
5866 
    iprot.readMessageEnd()
5867 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 5868 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 5869 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
5870 
    result.write(oprot)
5871 
    oprot.writeMessageEnd()
5872 
    oprot.trans.flush()
5873 
 
4910 phani.kuma 5874 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
5875 
    args = getDoasNotPickedUp_args()
5876 
    args.read(iprot)
5877 
    iprot.readMessageEnd()
5878 
    result = getDoasNotPickedUp_result()
5879 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
5880 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
5881 
    result.write(oprot)
5882 
    oprot.writeMessageEnd()
5883 
    oprot.trans.flush()
5884 
 
4741 phani.kuma 5885 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
5886 
    args = markReturnOrdersAsPickedUp_args()
5887 
    args.read(iprot)
5888 
    iprot.readMessageEnd()
5889 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 5890 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 5891 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
5892 
    result.write(oprot)
5893 
    oprot.writeMessageEnd()
5894 
    oprot.trans.flush()
5895 
 
4910 phani.kuma 5896 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
5897 
    args = getReturnOrdersNotPickedUp_args()
5898 
    args.read(iprot)
5899 
    iprot.readMessageEnd()
5900 
    result = getReturnOrdersNotPickedUp_result()
5901 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
5902 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
5903 
    result.write(oprot)
5904 
    oprot.writeMessageEnd()
5905 
    oprot.trans.flush()
5906 
 
2616 chandransh 5907 
  def process_receiveReturn(self, seqid, iprot, oprot):
5908 
    args = receiveReturn_args()
2591 chandransh 5909 
    args.read(iprot)
5910 
    iprot.readMessageEnd()
2616 chandransh 5911 
    result = receiveReturn_result()
2591 chandransh 5912 
    try:
4479 rajveer 5913 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 5914 
    except TransactionServiceException, ex:
5915 
      result.ex = ex
2616 chandransh 5916 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 5917 
    result.write(oprot)
5918 
    oprot.writeMessageEnd()
5919 
    oprot.trans.flush()
2536 chandransh 5920 
 
2591 chandransh 5921 
  def process_validateDoa(self, seqid, iprot, oprot):
5922 
    args = validateDoa_args()
5923 
    args.read(iprot)
5924 
    iprot.readMessageEnd()
5925 
    result = validateDoa_result()
5926 
    try:
5927 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
5928 
    except TransactionServiceException, ex:
5929 
      result.ex = ex
5930 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
5931 
    result.write(oprot)
5932 
    oprot.writeMessageEnd()
5933 
    oprot.trans.flush()
5934 
 
4495 rajveer 5935 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
5936 
    args = validateReturnProduct_args()
5937 
    args.read(iprot)
5938 
    iprot.readMessageEnd()
5939 
    result = validateReturnProduct_result()
5940 
    try:
5941 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
5942 
    except TransactionServiceException, ex:
5943 
      result.ex = ex
5944 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
5945 
    result.write(oprot)
5946 
    oprot.writeMessageEnd()
5947 
    oprot.trans.flush()
5948 
 
2616 chandransh 5949 
  def process_reshipOrder(self, seqid, iprot, oprot):
5950 
    args = reshipOrder_args()
5951 
    args.read(iprot)
5952 
    iprot.readMessageEnd()
5953 
    result = reshipOrder_result()
5954 
    try:
5955 
      result.success = self._handler.reshipOrder(args.orderId)
5956 
    except TransactionServiceException, ex:
5957 
      result.ex = ex
5958 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
5959 
    result.write(oprot)
5960 
    oprot.writeMessageEnd()
5961 
    oprot.trans.flush()
2591 chandransh 5962 
 
2616 chandransh 5963 
  def process_refundOrder(self, seqid, iprot, oprot):
5964 
    args = refundOrder_args()
5965 
    args.read(iprot)
5966 
    iprot.readMessageEnd()
5967 
    result = refundOrder_result()
5968 
    try:
3226 chandransh 5969 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 5970 
    except TransactionServiceException, ex:
5971 
      result.ex = ex
5972 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
5973 
    result.write(oprot)
5974 
    oprot.writeMessageEnd()
5975 
    oprot.trans.flush()
5976 
 
2690 chandransh 5977 
  def process_getReturnOrders(self, seqid, iprot, oprot):
5978 
    args = getReturnOrders_args()
5979 
    args.read(iprot)
5980 
    iprot.readMessageEnd()
5981 
    result = getReturnOrders_result()
5982 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
5983 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
5984 
    result.write(oprot)
5985 
    oprot.writeMessageEnd()
5986 
    oprot.trans.flush()
2616 chandransh 5987 
 
2700 chandransh 5988 
  def process_getReturnOrder(self, seqid, iprot, oprot):
5989 
    args = getReturnOrder_args()
5990 
    args.read(iprot)
5991 
    iprot.readMessageEnd()
5992 
    result = getReturnOrder_result()
5993 
    try:
5994 
      result.success = self._handler.getReturnOrder(args.id)
5995 
    except TransactionServiceException, ex:
5996 
      result.ex = ex
5997 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
5998 
    result.write(oprot)
5999 
    oprot.writeMessageEnd()
6000 
    oprot.trans.flush()
6001 
 
2690 chandransh 6002 
  def process_processReturn(self, seqid, iprot, oprot):
6003 
    args = processReturn_args()
6004 
    args.read(iprot)
6005 
    iprot.readMessageEnd()
6006 
    result = processReturn_result()
6007 
    try:
6008 
      self._handler.processReturn(args.returnOrderId)
6009 
    except TransactionServiceException, ex:
6010 
      result.ex = ex
6011 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
6012 
    result.write(oprot)
6013 
    oprot.writeMessageEnd()
6014 
    oprot.trans.flush()
6015 
 
3451 chandransh 6016 
  def process_updateWeight(self, seqid, iprot, oprot):
6017 
    args = updateWeight_args()
6018 
    args.read(iprot)
6019 
    iprot.readMessageEnd()
6020 
    result = updateWeight_result()
6021 
    try:
6022 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
6023 
    except TransactionServiceException, ex:
6024 
      result.ex = ex
6025 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
6026 
    result.write(oprot)
6027 
    oprot.writeMessageEnd()
6028 
    oprot.trans.flush()
2819 chandransh 6029 
 
3469 chandransh 6030 
  def process_changeItem(self, seqid, iprot, oprot):
6031 
    args = changeItem_args()
6032 
    args.read(iprot)
6033 
    iprot.readMessageEnd()
6034 
    result = changeItem_result()
6035 
    try:
6036 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
6037 
    except TransactionServiceException, ex:
6038 
      result.ex = ex
6039 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
6040 
    result.write(oprot)
6041 
    oprot.writeMessageEnd()
6042 
    oprot.trans.flush()
3451 chandransh 6043 
 
3469 chandransh 6044 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
6045 
    args = shiftToWarehouse_args()
6046 
    args.read(iprot)
6047 
    iprot.readMessageEnd()
6048 
    result = shiftToWarehouse_result()
6049 
    try:
6050 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
6051 
    except TransactionServiceException, ex:
6052 
      result.ex = ex
6053 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
6054 
    result.write(oprot)
6055 
    oprot.writeMessageEnd()
6056 
    oprot.trans.flush()
6057 
 
3553 chandransh 6058 
  def process_addDelayReason(self, seqid, iprot, oprot):
6059 
    args = addDelayReason_args()
6060 
    args.read(iprot)
6061 
    iprot.readMessageEnd()
6062 
    result = addDelayReason_result()
6063 
    try:
4647 rajveer 6064 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 6065 
    except TransactionServiceException, ex:
6066 
      result.ex = ex
6067 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
6068 
    result.write(oprot)
6069 
    oprot.writeMessageEnd()
6070 
    oprot.trans.flush()
3469 chandransh 6071 
 
3956 chandransh 6072 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
6073 
    args = reconcileCodCollection_args()
6074 
    args.read(iprot)
6075 
    iprot.readMessageEnd()
6076 
    result = reconcileCodCollection_result()
6077 
    try:
6078 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
6079 
    except TransactionServiceException, ex:
6080 
      result.ex = ex
6081 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
6082 
    result.write(oprot)
6083 
    oprot.writeMessageEnd()
6084 
    oprot.trans.flush()
3553 chandransh 6085 
 
4008 mandeep.dh 6086 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
6087 
    args = getTransactionsRequiringExtraProcessing_args()
6088 
    args.read(iprot)
6089 
    iprot.readMessageEnd()
6090 
    result = getTransactionsRequiringExtraProcessing_result()
6091 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
6092 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
6093 
    result.write(oprot)
6094 
    oprot.writeMessageEnd()
6095 
    oprot.trans.flush()
3956 chandransh 6096 
 
4008 mandeep.dh 6097 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
6098 
    args = markTransactionAsProcessed_args()
6099 
    args.read(iprot)
6100 
    iprot.readMessageEnd()
6101 
    result = markTransactionAsProcessed_result()
6102 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
6103 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
6104 
    result.write(oprot)
6105 
    oprot.writeMessageEnd()
6106 
    oprot.trans.flush()
6107 
 
4018 chandransh 6108 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
6109 
    args = getItemWiseRiskyOrdersCount_args()
6110 
    args.read(iprot)
6111 
    iprot.readMessageEnd()
6112 
    result = getItemWiseRiskyOrdersCount_result()
6113 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
6114 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
6115 
    result.write(oprot)
6116 
    oprot.writeMessageEnd()
6117 
    oprot.trans.flush()
4008 mandeep.dh 6118 
 
4295 varun.gupt 6119 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
6120 
    args = getOrdersForItemIds_args()
6121 
    args.read(iprot)
6122 
    iprot.readMessageEnd()
6123 
    result = getOrdersForItemIds_result()
6124 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
6125 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
6126 
    result.write(oprot)
6127 
    oprot.writeMessageEnd()
6128 
    oprot.trans.flush()
6129 
 
4247 rajveer 6130 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
6131 
    args = markOrderCancellationRequestReceived_args()
6132 
    args.read(iprot)
6133 
    iprot.readMessageEnd()
6134 
    result = markOrderCancellationRequestReceived_result()
6135 
    try:
6136 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
6137 
    except TransactionServiceException, ex:
6138 
      result.ex = ex
6139 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
6140 
    result.write(oprot)
6141 
    oprot.writeMessageEnd()
6142 
    oprot.trans.flush()
4018 chandransh 6143 
 
4247 rajveer 6144 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
6145 
    args = markOrderCancellationRequestConfirmed_args()
6146 
    args.read(iprot)
6147 
    iprot.readMessageEnd()
6148 
    result = markOrderCancellationRequestConfirmed_result()
6149 
    try:
6150 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
6151 
    except TransactionServiceException, ex:
6152 
      result.ex = ex
6153 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
6154 
    result.write(oprot)
6155 
    oprot.writeMessageEnd()
6156 
    oprot.trans.flush()
6157 
 
6158 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
6159 
    args = markOrderCancellationRequestDenied_args()
6160 
    args.read(iprot)
6161 
    iprot.readMessageEnd()
6162 
    result = markOrderCancellationRequestDenied_result()
6163 
    try:
6164 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
6165 
    except TransactionServiceException, ex:
6166 
      result.ex = ex
6167 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
6168 
    result.write(oprot)
6169 
    oprot.writeMessageEnd()
6170 
    oprot.trans.flush()
6171 
 
4258 rajveer 6172 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
6173 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 6174 
    args.read(iprot)
6175 
    iprot.readMessageEnd()
4258 rajveer 6176 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 6177 
    try:
4258 rajveer 6178 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 6179 
    except TransactionServiceException, ex:
6180 
      result.ex = ex
4258 rajveer 6181 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 6182 
    result.write(oprot)
6183 
    oprot.writeMessageEnd()
6184 
    oprot.trans.flush()
6185 
 
4259 anupam.sin 6186 
  def process_refundTransaction(self, seqid, iprot, oprot):
6187 
    args = refundTransaction_args()
6188 
    args.read(iprot)
6189 
    iprot.readMessageEnd()
6190 
    result = refundTransaction_result()
6191 
    try:
6192 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
6193 
    except TransactionServiceException, ex:
6194 
      result.ex = ex
6195 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
6196 
    result.write(oprot)
6197 
    oprot.writeMessageEnd()
6198 
    oprot.trans.flush()
4247 rajveer 6199 
 
4324 mandeep.dh 6200 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
6201 
    args = updateShipmentAddress_args()
6202 
    args.read(iprot)
6203 
    iprot.readMessageEnd()
6204 
    result = updateShipmentAddress_result()
6205 
    try:
6206 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
6207 
    except TransactionServiceException, ex:
6208 
      result.ex = ex
6209 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
6210 
    result.write(oprot)
6211 
    oprot.writeMessageEnd()
6212 
    oprot.trans.flush()
6213 
 
4285 rajveer 6214 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
6215 
    args = acceptOrdersForItemId_args()
6216 
    args.read(iprot)
6217 
    iprot.readMessageEnd()
6218 
    result = acceptOrdersForItemId_result()
6219 
    try:
6220 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
6221 
    except TransactionServiceException, ex:
6222 
      result.ex = ex
6223 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
6224 
    result.write(oprot)
6225 
    oprot.writeMessageEnd()
6226 
    oprot.trans.flush()
4259 anupam.sin 6227 
 
4303 rajveer 6228 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
6229 
    args = markOrdersAsPORaised_args()
6230 
    args.read(iprot)
6231 
    iprot.readMessageEnd()
6232 
    result = markOrdersAsPORaised_result()
6233 
    try:
4369 rajveer 6234 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6235 
    except TransactionServiceException, ex:
6236 
      result.ex = ex
6237 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
6238 
    result.write(oprot)
6239 
    oprot.writeMessageEnd()
6240 
    oprot.trans.flush()
4285 rajveer 6241 
 
4303 rajveer 6242 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
6243 
    args = markOrdersAsReversalInitiated_args()
6244 
    args.read(iprot)
6245 
    iprot.readMessageEnd()
6246 
    result = markOrdersAsReversalInitiated_result()
6247 
    try:
4369 rajveer 6248 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6249 
    except TransactionServiceException, ex:
6250 
      result.ex = ex
6251 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
6252 
    result.write(oprot)
6253 
    oprot.writeMessageEnd()
6254 
    oprot.trans.flush()
6255 
 
6256 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
6257 
    args = markOrdersAsNotAvailabke_args()
6258 
    args.read(iprot)
6259 
    iprot.readMessageEnd()
6260 
    result = markOrdersAsNotAvailabke_result()
6261 
    try:
4369 rajveer 6262 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6263 
    except TransactionServiceException, ex:
6264 
      result.ex = ex
6265 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
6266 
    result.write(oprot)
6267 
    oprot.writeMessageEnd()
6268 
    oprot.trans.flush()
6269 
 
4369 rajveer 6270 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
6271 
    args = markOrdersAsTimeout_args()
6272 
    args.read(iprot)
6273 
    iprot.readMessageEnd()
6274 
    result = markOrdersAsTimeout_result()
6275 
    try:
6276 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
6277 
    except TransactionServiceException, ex:
6278 
      result.ex = ex
6279 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
6280 
    result.write(oprot)
6281 
    oprot.writeMessageEnd()
6282 
    oprot.trans.flush()
4303 rajveer 6283 
 
4662 rajveer 6284 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
6285 
    args = markOrderAsLostInTransit_args()
6286 
    args.read(iprot)
6287 
    iprot.readMessageEnd()
6288 
    result = markOrderAsLostInTransit_result()
6289 
    try:
6290 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
6291 
    except TransactionServiceException, ex:
6292 
      result.ex = ex
6293 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
6294 
    result.write(oprot)
6295 
    oprot.writeMessageEnd()
6296 
    oprot.trans.flush()
6297 
 
4386 anupam.sin 6298 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
6299 
    args = getOrderForAwb_args()
6300 
    args.read(iprot)
6301 
    iprot.readMessageEnd()
6302 
    result = getOrderForAwb_result()
6303 
    try:
6304 
      result.success = self._handler.getOrderForAwb(args.awb)
6305 
    except TransactionServiceException, ex:
6306 
      result.ex = ex
6307 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
6308 
    result.write(oprot)
6309 
    oprot.writeMessageEnd()
6310 
    oprot.trans.flush()
4369 rajveer 6311 
 
4506 phani.kuma 6312 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
6313 
    args = getOrdersForProviderForStatus_args()
6314 
    args.read(iprot)
6315 
    iprot.readMessageEnd()
6316 
    result = getOrdersForProviderForStatus_result()
6317 
    try:
4910 phani.kuma 6318 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 6319 
    except TransactionServiceException, ex:
6320 
      result.ex = ex
6321 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
6322 
    result.write(oprot)
6323 
    oprot.writeMessageEnd()
6324 
    oprot.trans.flush()
4386 anupam.sin 6325 
 
4600 varun.gupt 6326 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
6327 
    args = getBilledOrdersForVendor_args()
6328 
    args.read(iprot)
6329 
    iprot.readMessageEnd()
6330 
    result = getBilledOrdersForVendor_result()
6331 
    try:
6332 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
6333 
    except TransactionServiceException, ex:
6334 
      result.ex = ex
6335 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
6336 
    result.write(oprot)
6337 
    oprot.writeMessageEnd()
6338 
    oprot.trans.flush()
4506 phani.kuma 6339 
 
4607 rajveer 6340 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
6341 
    args = getSlippedSippingDateOrders_args()
6342 
    args.read(iprot)
6343 
    iprot.readMessageEnd()
6344 
    result = getSlippedSippingDateOrders_result()
6345 
    try:
6346 
      result.success = self._handler.getSlippedSippingDateOrders()
6347 
    except TransactionServiceException, ex:
6348 
      result.ex = ex
6349 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
6350 
    result.write(oprot)
6351 
    oprot.writeMessageEnd()
6352 
    oprot.trans.flush()
6353 
 
4709 rajveer 6354 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
6355 
    args = getCancelledOrders_args()
6356 
    args.read(iprot)
6357 
    iprot.readMessageEnd()
6358 
    result = getCancelledOrders_result()
6359 
    try:
6360 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
6361 
    except TransactionServiceException, ex:
6362 
      result.ex = ex
6363 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
6364 
    result.write(oprot)
6365 
    oprot.writeMessageEnd()
6366 
    oprot.trans.flush()
6367 
 
4600 varun.gupt 6368 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
6369 
    args = saveBluedartSettlements_args()
6370 
    args.read(iprot)
6371 
    iprot.readMessageEnd()
6372 
    result = saveBluedartSettlements_result()
6373 
    try:
6374 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
6375 
    except TransactionServiceException, ex:
6376 
      result.ex = ex
6377 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
6378 
    result.write(oprot)
6379 
    oprot.writeMessageEnd()
6380 
    oprot.trans.flush()
6381 
 
6382 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
6383 
    args = savePaymentSettlements_args()
6384 
    args.read(iprot)
6385 
    iprot.readMessageEnd()
6386 
    result = savePaymentSettlements_result()
6387 
    try:
4905 varun.gupt 6388 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 6389 
    except TransactionServiceException, ex:
6390 
      result.ex = ex
6391 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
6392 
    result.write(oprot)
6393 
    oprot.writeMessageEnd()
6394 
    oprot.trans.flush()
6395 
 
6396 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
6397 
    args = saveEBSSettlementSummary_args()
6398 
    args.read(iprot)
6399 
    iprot.readMessageEnd()
6400 
    result = saveEBSSettlementSummary_result()
6401 
    try:
6402 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
6403 
    except TransactionServiceException, ex:
6404 
      result.ex = ex
6405 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
6406 
    result.write(oprot)
6407 
    oprot.writeMessageEnd()
6408 
    oprot.trans.flush()
6409 
 
5189 varun.gupt 6410 
  def process_getSettlementForReferenceId(self, seqid, iprot, oprot):
6411 
    args = getSettlementForReferenceId_args()
4600 varun.gupt 6412 
    args.read(iprot)
6413 
    iprot.readMessageEnd()
5189 varun.gupt 6414 
    result = getSettlementForReferenceId_result()
4600 varun.gupt 6415 
    try:
5189 varun.gupt 6416 
      result.success = self._handler.getSettlementForReferenceId(args.referenceId, args.isRefund)
4600 varun.gupt 6417 
    except TransactionServiceException, ex:
6418 
      result.ex = ex
5189 varun.gupt 6419 
    oprot.writeMessageBegin("getSettlementForReferenceId", TMessageType.REPLY, seqid)
4600 varun.gupt 6420 
    result.write(oprot)
6421 
    oprot.writeMessageEnd()
6422 
    oprot.trans.flush()
6423 
 
6424 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
6425 
    args = getEBSSettlementSummaries_args()
6426 
    args.read(iprot)
6427 
    iprot.readMessageEnd()
6428 
    result = getEBSSettlementSummaries_result()
6429 
    try:
6430 
      result.success = self._handler.getEBSSettlementSummaries()
6431 
    except TransactionServiceException, ex:
6432 
      result.ex = ex
6433 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
6434 
    result.write(oprot)
6435 
    oprot.writeMessageEnd()
6436 
    oprot.trans.flush()
6437 
 
6438 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
6439 
    args = markEBSSettlementUploaded_args()
6440 
    args.read(iprot)
6441 
    iprot.readMessageEnd()
6442 
    result = markEBSSettlementUploaded_result()
6443 
    try:
6444 
      self._handler.markEBSSettlementUploaded(args.settlementId)
6445 
    except TransactionServiceException, ex:
6446 
      result.ex = ex
6447 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
6448 
    result.write(oprot)
6449 
    oprot.writeMessageEnd()
6450 
    oprot.trans.flush()
6451 
 
6452 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
6453 
    args = getEBSSettlementDate_args()
6454 
    args.read(iprot)
6455 
    iprot.readMessageEnd()
6456 
    result = getEBSSettlementDate_result()
6457 
    try:
6458 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
6459 
    except TransactionServiceException, ex:
6460 
      result.ex = ex
6461 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
6462 
    result.write(oprot)
6463 
    oprot.writeMessageEnd()
6464 
    oprot.trans.flush()
6465 
 
4715 varun.gupt 6466 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
6467 
    args = getSettlementsByDate_args()
6468 
    args.read(iprot)
6469 
    iprot.readMessageEnd()
6470 
    result = getSettlementsByDate_result()
6471 
    try:
6472 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
6473 
    except TransactionServiceException, ex:
6474 
      result.ex = ex
6475 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
6476 
    result.write(oprot)
6477 
    oprot.writeMessageEnd()
6478 
    oprot.trans.flush()
4600 varun.gupt 6479 
 
4715 varun.gupt 6480 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
6481 
    args = getReshippedOrderIds_args()
6482 
    args.read(iprot)
6483 
    iprot.readMessageEnd()
6484 
    result = getReshippedOrderIds_result()
6485 
    try:
6486 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
6487 
    except TransactionServiceException, ex:
6488 
      result.ex = ex
6489 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
6490 
    result.write(oprot)
6491 
    oprot.writeMessageEnd()
6492 
    oprot.trans.flush()
6493 
 
4757 mandeep.dh 6494 
  def process_updateOrdersAsPORaised(self, seqid, iprot, oprot):
6495 
    args = updateOrdersAsPORaised_args()
6496 
    args.read(iprot)
6497 
    iprot.readMessageEnd()
6498 
    result = updateOrdersAsPORaised_result()
6499 
    try:
6500 
      self._handler.updateOrdersAsPORaised(args.itemIdQuantityMap, args.purchaseOrderId, args.warehouseId)
6501 
    except TransactionServiceException, ex:
6502 
      result.ex = ex
6503 
    oprot.writeMessageBegin("updateOrdersAsPORaised", TMessageType.REPLY, seqid)
6504 
    result.write(oprot)
6505 
    oprot.writeMessageEnd()
6506 
    oprot.trans.flush()
4715 varun.gupt 6507 
 
4875 varun.gupt 6508 
  def process_getOrdersWhereVendorNotPaid(self, seqid, iprot, oprot):
6509 
    args = getOrdersWhereVendorNotPaid_args()
6510 
    args.read(iprot)
6511 
    iprot.readMessageEnd()
6512 
    result = getOrdersWhereVendorNotPaid_result()
6513 
    try:
6514 
      result.success = self._handler.getOrdersWhereVendorNotPaid(args.vendorId)
6515 
    except TransactionServiceException, ex:
6516 
      result.ex = ex
6517 
    oprot.writeMessageBegin("getOrdersWhereVendorNotPaid", TMessageType.REPLY, seqid)
6518 
    result.write(oprot)
6519 
    oprot.writeMessageEnd()
6520 
    oprot.trans.flush()
4757 mandeep.dh 6521 
 
5031 varun.gupt 6522 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
6523 
    args = getStatusDistributionOfOrders_args()
6524 
    args.read(iprot)
6525 
    iprot.readMessageEnd()
6526 
    result = getStatusDistributionOfOrders_result()
6527 
    try:
6528 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
6529 
    except TransactionServiceException, ex:
6530 
      result.ex = ex
6531 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
6532 
    result.write(oprot)
6533 
    oprot.writeMessageEnd()
6534 
    oprot.trans.flush()
4875 varun.gupt 6535 
 
5067 varun.gupt 6536 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
6537 
    args = getOrderIdsForStatus_args()
6538 
    args.read(iprot)
6539 
    iprot.readMessageEnd()
6540 
    result = getOrderIdsForStatus_result()
6541 
    try:
6542 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
6543 
    except TransactionServiceException, ex:
6544 
      result.ex = ex
6545 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
6546 
    result.write(oprot)
6547 
    oprot.writeMessageEnd()
6548 
    oprot.trans.flush()
5031 varun.gupt 6549 
 
5099 varun.gupt 6550 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
6551 
    args = updateOrderAsPaidToVendor_args()
6552 
    args.read(iprot)
6553 
    iprot.readMessageEnd()
6554 
    result = updateOrderAsPaidToVendor_result()
6555 
    try:
6556 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
6557 
    except TransactionServiceException, ex:
6558 
      result.ex = ex
6559 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
6560 
    result.write(oprot)
6561 
    oprot.writeMessageEnd()
6562 
    oprot.trans.flush()
5067 varun.gupt 6563 
 
5099 varun.gupt 6564 
 
94 ashish 6565 
# HELPER FUNCTIONS AND STRUCTURES
6566 
 
6567 
class createTransaction_args:
6568 
  """
6569 
  Attributes:
6570 
   - transaction
6571 
  """
6572 
 
6573 
  thrift_spec = (
6574 
    None, # 0
6575 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
6576 
  )
6577 
 
6578 
  def __init__(self, transaction=None,):
6579 
    self.transaction = transaction
6580 
 
6581 
  def read(self, iprot):
6582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6584 
      return
6585 
    iprot.readStructBegin()
6586 
    while True:
6587 
      (fname, ftype, fid) = iprot.readFieldBegin()
6588 
      if ftype == TType.STOP:
6589 
        break
6590 
      if fid == 1:
6591 
        if ftype == TType.STRUCT:
6592 
          self.transaction = Transaction()
6593 
          self.transaction.read(iprot)
6594 
        else:
6595 
          iprot.skip(ftype)
6596 
      else:
6597 
        iprot.skip(ftype)
6598 
      iprot.readFieldEnd()
6599 
    iprot.readStructEnd()
6600 
 
6601 
  def write(self, oprot):
6602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6604 
      return
6605 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 6606 
    if self.transaction is not None:
94 ashish 6607 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
6608 
      self.transaction.write(oprot)
6609 
      oprot.writeFieldEnd()
6610 
    oprot.writeFieldStop()
6611 
    oprot.writeStructEnd()
6612 
 
3431 rajveer 6613 
  def validate(self):
6614 
    return
6615 
 
6616 
 
94 ashish 6617 
  def __repr__(self):
6618 
    L = ['%s=%r' % (key, value)
6619 
      for key, value in self.__dict__.iteritems()]
6620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6621 
 
6622 
  def __eq__(self, other):
6623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6624 
 
6625 
  def __ne__(self, other):
6626 
    return not (self == other)
6627 
 
6628 
class createTransaction_result:
6629 
  """
6630 
  Attributes:
132 ashish 6631 
   - success
94 ashish 6632 
   - ex
6633 
  """
6634 
 
6635 
  thrift_spec = (
132 ashish 6636 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 6637 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6638 
  )
6639 
 
132 ashish 6640 
  def __init__(self, success=None, ex=None,):
6641 
    self.success = success
94 ashish 6642 
    self.ex = ex
6643 
 
6644 
  def read(self, iprot):
6645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6647 
      return
6648 
    iprot.readStructBegin()
6649 
    while True:
6650 
      (fname, ftype, fid) = iprot.readFieldBegin()
6651 
      if ftype == TType.STOP:
6652 
        break
132 ashish 6653 
      if fid == 0:
6654 
        if ftype == TType.I64:
6655 
          self.success = iprot.readI64();
6656 
        else:
6657 
          iprot.skip(ftype)
6658 
      elif fid == 1:
94 ashish 6659 
        if ftype == TType.STRUCT:
6660 
          self.ex = TransactionServiceException()
6661 
          self.ex.read(iprot)
6662 
        else:
6663 
          iprot.skip(ftype)
6664 
      else:
6665 
        iprot.skip(ftype)
6666 
      iprot.readFieldEnd()
6667 
    iprot.readStructEnd()
6668 
 
6669 
  def write(self, oprot):
6670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6672 
      return
6673 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 6674 
    if self.success is not None:
132 ashish 6675 
      oprot.writeFieldBegin('success', TType.I64, 0)
6676 
      oprot.writeI64(self.success)
6677 
      oprot.writeFieldEnd()
3431 rajveer 6678 
    if self.ex is not None:
94 ashish 6679 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6680 
      self.ex.write(oprot)
6681 
      oprot.writeFieldEnd()
6682 
    oprot.writeFieldStop()
6683 
    oprot.writeStructEnd()
6684 
 
3431 rajveer 6685 
  def validate(self):
6686 
    return
6687 
 
6688 
 
94 ashish 6689 
  def __repr__(self):
6690 
    L = ['%s=%r' % (key, value)
6691 
      for key, value in self.__dict__.iteritems()]
6692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6693 
 
6694 
  def __eq__(self, other):
6695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6696 
 
6697 
  def __ne__(self, other):
6698 
    return not (self == other)
6699 
 
6700 
class getTransaction_args:
6701 
  """
6702 
  Attributes:
6703 
   - id
6704 
  """
6705 
 
6706 
  thrift_spec = (
6707 
    None, # 0
6708 
    (1, TType.I64, 'id', None, None, ), # 1
6709 
  )
6710 
 
6711 
  def __init__(self, id=None,):
6712 
    self.id = id
6713 
 
6714 
  def read(self, iprot):
6715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6717 
      return
6718 
    iprot.readStructBegin()
6719 
    while True:
6720 
      (fname, ftype, fid) = iprot.readFieldBegin()
6721 
      if ftype == TType.STOP:
6722 
        break
6723 
      if fid == 1:
6724 
        if ftype == TType.I64:
6725 
          self.id = iprot.readI64();
6726 
        else:
6727 
          iprot.skip(ftype)
6728 
      else:
6729 
        iprot.skip(ftype)
6730 
      iprot.readFieldEnd()
6731 
    iprot.readStructEnd()
6732 
 
6733 
  def write(self, oprot):
6734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6736 
      return
6737 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 6738 
    if self.id is not None:
94 ashish 6739 
      oprot.writeFieldBegin('id', TType.I64, 1)
6740 
      oprot.writeI64(self.id)
6741 
      oprot.writeFieldEnd()
6742 
    oprot.writeFieldStop()
6743 
    oprot.writeStructEnd()
6744 
 
3431 rajveer 6745 
  def validate(self):
6746 
    return
6747 
 
6748 
 
94 ashish 6749 
  def __repr__(self):
6750 
    L = ['%s=%r' % (key, value)
6751 
      for key, value in self.__dict__.iteritems()]
6752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6753 
 
6754 
  def __eq__(self, other):
6755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6756 
 
6757 
  def __ne__(self, other):
6758 
    return not (self == other)
6759 
 
6760 
class getTransaction_result:
6761 
  """
6762 
  Attributes:
6763 
   - success
6764 
   - ex
6765 
  """
6766 
 
6767 
  thrift_spec = (
6768 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
6769 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6770 
  )
6771 
 
6772 
  def __init__(self, success=None, ex=None,):
6773 
    self.success = success
6774 
    self.ex = ex
6775 
 
6776 
  def read(self, iprot):
6777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6779 
      return
6780 
    iprot.readStructBegin()
6781 
    while True:
6782 
      (fname, ftype, fid) = iprot.readFieldBegin()
6783 
      if ftype == TType.STOP:
6784 
        break
6785 
      if fid == 0:
6786 
        if ftype == TType.STRUCT:
6787 
          self.success = Transaction()
6788 
          self.success.read(iprot)
6789 
        else:
6790 
          iprot.skip(ftype)
6791 
      elif fid == 1:
6792 
        if ftype == TType.STRUCT:
6793 
          self.ex = TransactionServiceException()
6794 
          self.ex.read(iprot)
6795 
        else:
6796 
          iprot.skip(ftype)
6797 
      else:
6798 
        iprot.skip(ftype)
6799 
      iprot.readFieldEnd()
6800 
    iprot.readStructEnd()
6801 
 
6802 
  def write(self, oprot):
6803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6805 
      return
6806 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 6807 
    if self.success is not None:
94 ashish 6808 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6809 
      self.success.write(oprot)
6810 
      oprot.writeFieldEnd()
3431 rajveer 6811 
    if self.ex is not None:
94 ashish 6812 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6813 
      self.ex.write(oprot)
6814 
      oprot.writeFieldEnd()
6815 
    oprot.writeFieldStop()
6816 
    oprot.writeStructEnd()
6817 
 
3431 rajveer 6818 
  def validate(self):
6819 
    return
6820 
 
6821 
 
94 ashish 6822 
  def __repr__(self):
6823 
    L = ['%s=%r' % (key, value)
6824 
      for key, value in self.__dict__.iteritems()]
6825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6826 
 
6827 
  def __eq__(self, other):
6828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6829 
 
6830 
  def __ne__(self, other):
6831 
    return not (self == other)
6832 
 
6833 
class getTransactionsForCustomer_args:
6834 
  """
6835 
  Attributes:
6836 
   - customerId
6837 
   - from_date
6838 
   - to_date
6839 
   - status
6840 
  """
6841 
 
6842 
  thrift_spec = (
6843 
    None, # 0
6844 
    (1, TType.I64, 'customerId', None, None, ), # 1
6845 
    (2, TType.I64, 'from_date', None, None, ), # 2
6846 
    (3, TType.I64, 'to_date', None, None, ), # 3
6847 
    (4, TType.I32, 'status', None, None, ), # 4
6848 
  )
6849 
 
6850 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
6851 
    self.customerId = customerId
6852 
    self.from_date = from_date
6853 
    self.to_date = to_date
6854 
    self.status = status
6855 
 
6856 
  def read(self, iprot):
6857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6859 
      return
6860 
    iprot.readStructBegin()
6861 
    while True:
6862 
      (fname, ftype, fid) = iprot.readFieldBegin()
6863 
      if ftype == TType.STOP:
6864 
        break
6865 
      if fid == 1:
6866 
        if ftype == TType.I64:
6867 
          self.customerId = iprot.readI64();
6868 
        else:
6869 
          iprot.skip(ftype)
6870 
      elif fid == 2:
6871 
        if ftype == TType.I64:
6872 
          self.from_date = iprot.readI64();
6873 
        else:
6874 
          iprot.skip(ftype)
6875 
      elif fid == 3:
6876 
        if ftype == TType.I64:
6877 
          self.to_date = iprot.readI64();
6878 
        else:
6879 
          iprot.skip(ftype)
6880 
      elif fid == 4:
6881 
        if ftype == TType.I32:
6882 
          self.status = iprot.readI32();
6883 
        else:
6884 
          iprot.skip(ftype)
6885 
      else:
6886 
        iprot.skip(ftype)
6887 
      iprot.readFieldEnd()
6888 
    iprot.readStructEnd()
6889 
 
6890 
  def write(self, oprot):
6891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6893 
      return
6894 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 6895 
    if self.customerId is not None:
94 ashish 6896 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6897 
      oprot.writeI64(self.customerId)
6898 
      oprot.writeFieldEnd()
3431 rajveer 6899 
    if self.from_date is not None:
94 ashish 6900 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6901 
      oprot.writeI64(self.from_date)
6902 
      oprot.writeFieldEnd()
3431 rajveer 6903 
    if self.to_date is not None:
94 ashish 6904 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6905 
      oprot.writeI64(self.to_date)
6906 
      oprot.writeFieldEnd()
3431 rajveer 6907 
    if self.status is not None:
94 ashish 6908 
      oprot.writeFieldBegin('status', TType.I32, 4)
6909 
      oprot.writeI32(self.status)
6910 
      oprot.writeFieldEnd()
6911 
    oprot.writeFieldStop()
6912 
    oprot.writeStructEnd()
6913 
 
3431 rajveer 6914 
  def validate(self):
6915 
    return
6916 
 
6917 
 
94 ashish 6918 
  def __repr__(self):
6919 
    L = ['%s=%r' % (key, value)
6920 
      for key, value in self.__dict__.iteritems()]
6921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6922 
 
6923 
  def __eq__(self, other):
6924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6925 
 
6926 
  def __ne__(self, other):
6927 
    return not (self == other)
6928 
 
6929 
class getTransactionsForCustomer_result:
6930 
  """
6931 
  Attributes:
6932 
   - success
6933 
   - ex
6934 
  """
6935 
 
6936 
  thrift_spec = (
6937 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6938 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6939 
  )
6940 
 
6941 
  def __init__(self, success=None, ex=None,):
6942 
    self.success = success
6943 
    self.ex = ex
6944 
 
6945 
  def read(self, iprot):
6946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6948 
      return
6949 
    iprot.readStructBegin()
6950 
    while True:
6951 
      (fname, ftype, fid) = iprot.readFieldBegin()
6952 
      if ftype == TType.STOP:
6953 
        break
6954 
      if fid == 0:
6955 
        if ftype == TType.LIST:
6956 
          self.success = []
5031 varun.gupt 6957 
          (_etype66, _size63) = iprot.readListBegin()
6958 
          for _i67 in xrange(_size63):
6959 
            _elem68 = Transaction()
6960 
            _elem68.read(iprot)
6961 
            self.success.append(_elem68)
94 ashish 6962 
          iprot.readListEnd()
6963 
        else:
6964 
          iprot.skip(ftype)
6965 
      elif fid == 1:
6966 
        if ftype == TType.STRUCT:
6967 
          self.ex = TransactionServiceException()
6968 
          self.ex.read(iprot)
6969 
        else:
6970 
          iprot.skip(ftype)
6971 
      else:
6972 
        iprot.skip(ftype)
6973 
      iprot.readFieldEnd()
6974 
    iprot.readStructEnd()
6975 
 
6976 
  def write(self, oprot):
6977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6979 
      return
6980 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 6981 
    if self.success is not None:
94 ashish 6982 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6983 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 6984 
      for iter69 in self.success:
6985 
        iter69.write(oprot)
94 ashish 6986 
      oprot.writeListEnd()
6987 
      oprot.writeFieldEnd()
3431 rajveer 6988 
    if self.ex is not None:
94 ashish 6989 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6990 
      self.ex.write(oprot)
6991 
      oprot.writeFieldEnd()
6992 
    oprot.writeFieldStop()
6993 
    oprot.writeStructEnd()
6994 
 
3431 rajveer 6995 
  def validate(self):
6996 
    return
6997 
 
6998 
 
94 ashish 6999 
  def __repr__(self):
7000 
    L = ['%s=%r' % (key, value)
7001 
      for key, value in self.__dict__.iteritems()]
7002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7003 
 
7004 
  def __eq__(self, other):
7005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7006 
 
7007 
  def __ne__(self, other):
7008 
    return not (self == other)
7009 
 
132 ashish 7010 
class getTransactionsForShoppingCartId_args:
7011 
  """
7012 
  Attributes:
7013 
   - shoppingCartId
7014 
  """
7015 
 
7016 
  thrift_spec = (
7017 
    None, # 0
7018 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
7019 
  )
7020 
 
7021 
  def __init__(self, shoppingCartId=None,):
7022 
    self.shoppingCartId = shoppingCartId
7023 
 
7024 
  def read(self, iprot):
7025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7027 
      return
7028 
    iprot.readStructBegin()
7029 
    while True:
7030 
      (fname, ftype, fid) = iprot.readFieldBegin()
7031 
      if ftype == TType.STOP:
7032 
        break
7033 
      if fid == 1:
7034 
        if ftype == TType.I64:
7035 
          self.shoppingCartId = iprot.readI64();
7036 
        else:
7037 
          iprot.skip(ftype)
7038 
      else:
7039 
        iprot.skip(ftype)
7040 
      iprot.readFieldEnd()
7041 
    iprot.readStructEnd()
7042 
 
7043 
  def write(self, oprot):
7044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7046 
      return
7047 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 7048 
    if self.shoppingCartId is not None:
132 ashish 7049 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
7050 
      oprot.writeI64(self.shoppingCartId)
7051 
      oprot.writeFieldEnd()
7052 
    oprot.writeFieldStop()
7053 
    oprot.writeStructEnd()
7054 
 
3431 rajveer 7055 
  def validate(self):
7056 
    return
7057 
 
7058 
 
132 ashish 7059 
  def __repr__(self):
7060 
    L = ['%s=%r' % (key, value)
7061 
      for key, value in self.__dict__.iteritems()]
7062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7063 
 
7064 
  def __eq__(self, other):
7065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7066 
 
7067 
  def __ne__(self, other):
7068 
    return not (self == other)
7069 
 
7070 
class getTransactionsForShoppingCartId_result:
7071 
  """
7072 
  Attributes:
7073 
   - success
7074 
   - ex
7075 
  """
7076 
 
7077 
  thrift_spec = (
7078 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7079 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7080 
  )
7081 
 
7082 
  def __init__(self, success=None, ex=None,):
7083 
    self.success = success
7084 
    self.ex = ex
7085 
 
7086 
  def read(self, iprot):
7087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7089 
      return
7090 
    iprot.readStructBegin()
7091 
    while True:
7092 
      (fname, ftype, fid) = iprot.readFieldBegin()
7093 
      if ftype == TType.STOP:
7094 
        break
7095 
      if fid == 0:
7096 
        if ftype == TType.LIST:
7097 
          self.success = []
5031 varun.gupt 7098 
          (_etype73, _size70) = iprot.readListBegin()
7099 
          for _i74 in xrange(_size70):
7100 
            _elem75 = Transaction()
7101 
            _elem75.read(iprot)
7102 
            self.success.append(_elem75)
132 ashish 7103 
          iprot.readListEnd()
7104 
        else:
7105 
          iprot.skip(ftype)
7106 
      elif fid == 1:
7107 
        if ftype == TType.STRUCT:
7108 
          self.ex = TransactionServiceException()
7109 
          self.ex.read(iprot)
7110 
        else:
7111 
          iprot.skip(ftype)
7112 
      else:
7113 
        iprot.skip(ftype)
7114 
      iprot.readFieldEnd()
7115 
    iprot.readStructEnd()
7116 
 
7117 
  def write(self, oprot):
7118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7120 
      return
7121 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 7122 
    if self.success is not None:
132 ashish 7123 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7124 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7125 
      for iter76 in self.success:
7126 
        iter76.write(oprot)
132 ashish 7127 
      oprot.writeListEnd()
7128 
      oprot.writeFieldEnd()
3431 rajveer 7129 
    if self.ex is not None:
132 ashish 7130 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7131 
      self.ex.write(oprot)
7132 
      oprot.writeFieldEnd()
7133 
    oprot.writeFieldStop()
7134 
    oprot.writeStructEnd()
7135 
 
3431 rajveer 7136 
  def validate(self):
7137 
    return
7138 
 
7139 
 
132 ashish 7140 
  def __repr__(self):
7141 
    L = ['%s=%r' % (key, value)
7142 
      for key, value in self.__dict__.iteritems()]
7143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7144 
 
7145 
  def __eq__(self, other):
7146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7147 
 
7148 
  def __ne__(self, other):
7149 
    return not (self == other)
7150 
 
94 ashish 7151 
class getTransactionStatus_args:
7152 
  """
7153 
  Attributes:
7154 
   - transactionId
7155 
  """
7156 
 
7157 
  thrift_spec = (
7158 
    None, # 0
7159 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7160 
  )
7161 
 
7162 
  def __init__(self, transactionId=None,):
7163 
    self.transactionId = transactionId
7164 
 
7165 
  def read(self, iprot):
7166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7168 
      return
7169 
    iprot.readStructBegin()
7170 
    while True:
7171 
      (fname, ftype, fid) = iprot.readFieldBegin()
7172 
      if ftype == TType.STOP:
7173 
        break
7174 
      if fid == 1:
7175 
        if ftype == TType.I64:
7176 
          self.transactionId = iprot.readI64();
7177 
        else:
7178 
          iprot.skip(ftype)
7179 
      else:
7180 
        iprot.skip(ftype)
7181 
      iprot.readFieldEnd()
7182 
    iprot.readStructEnd()
7183 
 
7184 
  def write(self, oprot):
7185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7187 
      return
7188 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 7189 
    if self.transactionId is not None:
94 ashish 7190 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7191 
      oprot.writeI64(self.transactionId)
7192 
      oprot.writeFieldEnd()
7193 
    oprot.writeFieldStop()
7194 
    oprot.writeStructEnd()
7195 
 
3431 rajveer 7196 
  def validate(self):
7197 
    return
7198 
 
7199 
 
94 ashish 7200 
  def __repr__(self):
7201 
    L = ['%s=%r' % (key, value)
7202 
      for key, value in self.__dict__.iteritems()]
7203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7204 
 
7205 
  def __eq__(self, other):
7206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7207 
 
7208 
  def __ne__(self, other):
7209 
    return not (self == other)
7210 
 
7211 
class getTransactionStatus_result:
7212 
  """
7213 
  Attributes:
7214 
   - success
7215 
   - ex
7216 
  """
7217 
 
7218 
  thrift_spec = (
7219 
    (0, TType.I32, 'success', None, None, ), # 0
7220 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7221 
  )
7222 
 
7223 
  def __init__(self, success=None, ex=None,):
7224 
    self.success = success
7225 
    self.ex = ex
7226 
 
7227 
  def read(self, iprot):
7228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7230 
      return
7231 
    iprot.readStructBegin()
7232 
    while True:
7233 
      (fname, ftype, fid) = iprot.readFieldBegin()
7234 
      if ftype == TType.STOP:
7235 
        break
7236 
      if fid == 0:
7237 
        if ftype == TType.I32:
7238 
          self.success = iprot.readI32();
7239 
        else:
7240 
          iprot.skip(ftype)
7241 
      elif fid == 1:
7242 
        if ftype == TType.STRUCT:
7243 
          self.ex = TransactionServiceException()
7244 
          self.ex.read(iprot)
7245 
        else:
7246 
          iprot.skip(ftype)
7247 
      else:
7248 
        iprot.skip(ftype)
7249 
      iprot.readFieldEnd()
7250 
    iprot.readStructEnd()
7251 
 
7252 
  def write(self, oprot):
7253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7255 
      return
7256 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 7257 
    if self.success is not None:
94 ashish 7258 
      oprot.writeFieldBegin('success', TType.I32, 0)
7259 
      oprot.writeI32(self.success)
7260 
      oprot.writeFieldEnd()
3431 rajveer 7261 
    if self.ex is not None:
94 ashish 7262 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7263 
      self.ex.write(oprot)
7264 
      oprot.writeFieldEnd()
7265 
    oprot.writeFieldStop()
7266 
    oprot.writeStructEnd()
7267 
 
3431 rajveer 7268 
  def validate(self):
7269 
    return
7270 
 
7271 
 
94 ashish 7272 
  def __repr__(self):
7273 
    L = ['%s=%r' % (key, value)
7274 
      for key, value in self.__dict__.iteritems()]
7275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7276 
 
7277 
  def __eq__(self, other):
7278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7279 
 
7280 
  def __ne__(self, other):
7281 
    return not (self == other)
7282 
 
7283 
class changeTransactionStatus_args:
7284 
  """
7285 
  Attributes:
7286 
   - transactionId
7287 
   - status
7288 
   - description
7289 
  """
7290 
 
7291 
  thrift_spec = (
7292 
    None, # 0
7293 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7294 
    (2, TType.I32, 'status', None, None, ), # 2
7295 
    (3, TType.STRING, 'description', None, None, ), # 3
7296 
  )
7297 
 
7298 
  def __init__(self, transactionId=None, status=None, description=None,):
7299 
    self.transactionId = transactionId
7300 
    self.status = status
7301 
    self.description = description
7302 
 
7303 
  def read(self, iprot):
7304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7306 
      return
7307 
    iprot.readStructBegin()
7308 
    while True:
7309 
      (fname, ftype, fid) = iprot.readFieldBegin()
7310 
      if ftype == TType.STOP:
7311 
        break
7312 
      if fid == 1:
7313 
        if ftype == TType.I64:
7314 
          self.transactionId = iprot.readI64();
7315 
        else:
7316 
          iprot.skip(ftype)
7317 
      elif fid == 2:
7318 
        if ftype == TType.I32:
7319 
          self.status = iprot.readI32();
7320 
        else:
7321 
          iprot.skip(ftype)
7322 
      elif fid == 3:
7323 
        if ftype == TType.STRING:
7324 
          self.description = iprot.readString();
7325 
        else:
7326 
          iprot.skip(ftype)
7327 
      else:
7328 
        iprot.skip(ftype)
7329 
      iprot.readFieldEnd()
7330 
    iprot.readStructEnd()
7331 
 
7332 
  def write(self, oprot):
7333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7335 
      return
7336 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 7337 
    if self.transactionId is not None:
94 ashish 7338 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7339 
      oprot.writeI64(self.transactionId)
7340 
      oprot.writeFieldEnd()
3431 rajveer 7341 
    if self.status is not None:
94 ashish 7342 
      oprot.writeFieldBegin('status', TType.I32, 2)
7343 
      oprot.writeI32(self.status)
7344 
      oprot.writeFieldEnd()
3431 rajveer 7345 
    if self.description is not None:
94 ashish 7346 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7347 
      oprot.writeString(self.description)
7348 
      oprot.writeFieldEnd()
7349 
    oprot.writeFieldStop()
7350 
    oprot.writeStructEnd()
7351 
 
3431 rajveer 7352 
  def validate(self):
7353 
    return
7354 
 
7355 
 
94 ashish 7356 
  def __repr__(self):
7357 
    L = ['%s=%r' % (key, value)
7358 
      for key, value in self.__dict__.iteritems()]
7359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7360 
 
7361 
  def __eq__(self, other):
7362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7363 
 
7364 
  def __ne__(self, other):
7365 
    return not (self == other)
7366 
 
7367 
class changeTransactionStatus_result:
7368 
  """
7369 
  Attributes:
7370 
   - success
7371 
   - ex
7372 
  """
7373 
 
7374 
  thrift_spec = (
7375 
    (0, TType.BOOL, 'success', None, None, ), # 0
7376 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7377 
  )
7378 
 
7379 
  def __init__(self, success=None, ex=None,):
7380 
    self.success = success
7381 
    self.ex = ex
7382 
 
7383 
  def read(self, iprot):
7384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7386 
      return
7387 
    iprot.readStructBegin()
7388 
    while True:
7389 
      (fname, ftype, fid) = iprot.readFieldBegin()
7390 
      if ftype == TType.STOP:
7391 
        break
7392 
      if fid == 0:
7393 
        if ftype == TType.BOOL:
7394 
          self.success = iprot.readBool();
7395 
        else:
7396 
          iprot.skip(ftype)
7397 
      elif fid == 1:
7398 
        if ftype == TType.STRUCT:
7399 
          self.ex = TransactionServiceException()
7400 
          self.ex.read(iprot)
7401 
        else:
7402 
          iprot.skip(ftype)
7403 
      else:
7404 
        iprot.skip(ftype)
7405 
      iprot.readFieldEnd()
7406 
    iprot.readStructEnd()
7407 
 
7408 
  def write(self, oprot):
7409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7411 
      return
7412 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 7413 
    if self.success is not None:
94 ashish 7414 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7415 
      oprot.writeBool(self.success)
7416 
      oprot.writeFieldEnd()
3431 rajveer 7417 
    if self.ex is not None:
94 ashish 7418 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7419 
      self.ex.write(oprot)
7420 
      oprot.writeFieldEnd()
7421 
    oprot.writeFieldStop()
7422 
    oprot.writeStructEnd()
7423 
 
3431 rajveer 7424 
  def validate(self):
7425 
    return
7426 
 
7427 
 
94 ashish 7428 
  def __repr__(self):
7429 
    L = ['%s=%r' % (key, value)
7430 
      for key, value in self.__dict__.iteritems()]
7431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7432 
 
7433 
  def __eq__(self, other):
7434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7435 
 
7436 
  def __ne__(self, other):
7437 
    return not (self == other)
7438 
 
1398 varun.gupt 7439 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 7440 
  """
7441 
  Attributes:
7442 
   - transactionId
7443 
  """
7444 
 
7445 
  thrift_spec = (
7446 
    None, # 0
7447 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7448 
  )
7449 
 
7450 
  def __init__(self, transactionId=None,):
7451 
    self.transactionId = transactionId
7452 
 
7453 
  def read(self, iprot):
7454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7456 
      return
7457 
    iprot.readStructBegin()
7458 
    while True:
7459 
      (fname, ftype, fid) = iprot.readFieldBegin()
7460 
      if ftype == TType.STOP:
7461 
        break
7462 
      if fid == 1:
7463 
        if ftype == TType.I64:
7464 
          self.transactionId = iprot.readI64();
7465 
        else:
7466 
          iprot.skip(ftype)
7467 
      else:
7468 
        iprot.skip(ftype)
7469 
      iprot.readFieldEnd()
7470 
    iprot.readStructEnd()
7471 
 
7472 
  def write(self, oprot):
7473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7475 
      return
1398 varun.gupt 7476 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 7477 
    if self.transactionId is not None:
1382 varun.gupt 7478 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7479 
      oprot.writeI64(self.transactionId)
7480 
      oprot.writeFieldEnd()
7481 
    oprot.writeFieldStop()
7482 
    oprot.writeStructEnd()
7483 
 
3431 rajveer 7484 
  def validate(self):
7485 
    return
7486 
 
7487 
 
1382 varun.gupt 7488 
  def __repr__(self):
7489 
    L = ['%s=%r' % (key, value)
7490 
      for key, value in self.__dict__.iteritems()]
7491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7492 
 
7493 
  def __eq__(self, other):
7494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7495 
 
7496 
  def __ne__(self, other):
7497 
    return not (self == other)
7498 
 
1398 varun.gupt 7499 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 7500 
  """
7501 
  Attributes:
7502 
   - success
7503 
   - ex
7504 
  """
7505 
 
7506 
  thrift_spec = (
7507 
    (0, TType.BOOL, 'success', None, None, ), # 0
7508 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7509 
  )
7510 
 
7511 
  def __init__(self, success=None, ex=None,):
7512 
    self.success = success
7513 
    self.ex = ex
7514 
 
7515 
  def read(self, iprot):
7516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7518 
      return
7519 
    iprot.readStructBegin()
7520 
    while True:
7521 
      (fname, ftype, fid) = iprot.readFieldBegin()
7522 
      if ftype == TType.STOP:
7523 
        break
7524 
      if fid == 0:
7525 
        if ftype == TType.BOOL:
7526 
          self.success = iprot.readBool();
7527 
        else:
7528 
          iprot.skip(ftype)
7529 
      elif fid == 1:
7530 
        if ftype == TType.STRUCT:
7531 
          self.ex = TransactionServiceException()
7532 
          self.ex.read(iprot)
7533 
        else:
7534 
          iprot.skip(ftype)
7535 
      else:
7536 
        iprot.skip(ftype)
7537 
      iprot.readFieldEnd()
7538 
    iprot.readStructEnd()
7539 
 
7540 
  def write(self, oprot):
7541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7543 
      return
1398 varun.gupt 7544 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 7545 
    if self.success is not None:
1382 varun.gupt 7546 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7547 
      oprot.writeBool(self.success)
7548 
      oprot.writeFieldEnd()
3431 rajveer 7549 
    if self.ex is not None:
1382 varun.gupt 7550 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7551 
      self.ex.write(oprot)
7552 
      oprot.writeFieldEnd()
7553 
    oprot.writeFieldStop()
7554 
    oprot.writeStructEnd()
7555 
 
3431 rajveer 7556 
  def validate(self):
7557 
    return
7558 
 
7559 
 
1382 varun.gupt 7560 
  def __repr__(self):
7561 
    L = ['%s=%r' % (key, value)
7562 
      for key, value in self.__dict__.iteritems()]
7563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7564 
 
7565 
  def __eq__(self, other):
7566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7567 
 
7568 
  def __ne__(self, other):
7569 
    return not (self == other)
7570 
 
483 rajveer 7571 
class getAllOrders_args:
94 ashish 7572 
  """
7573 
  Attributes:
4801 anupam.sin 7574 
   - statuses
483 rajveer 7575 
   - from_date
7576 
   - to_date
7577 
   - warehouse_id
94 ashish 7578 
  """
7579 
 
7580 
  thrift_spec = (
7581 
    None, # 0
4801 anupam.sin 7582 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 7583 
    (2, TType.I64, 'from_date', None, None, ), # 2
7584 
    (3, TType.I64, 'to_date', None, None, ), # 3
7585 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 7586 
  )
7587 
 
4801 anupam.sin 7588 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
7589 
    self.statuses = statuses
483 rajveer 7590 
    self.from_date = from_date
7591 
    self.to_date = to_date
7592 
    self.warehouse_id = warehouse_id
94 ashish 7593 
 
7594 
  def read(self, iprot):
7595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7597 
      return
7598 
    iprot.readStructBegin()
7599 
    while True:
7600 
      (fname, ftype, fid) = iprot.readFieldBegin()
7601 
      if ftype == TType.STOP:
7602 
        break
7603 
      if fid == 1:
4801 anupam.sin 7604 
        if ftype == TType.LIST:
7605 
          self.statuses = []
5031 varun.gupt 7606 
          (_etype80, _size77) = iprot.readListBegin()
7607 
          for _i81 in xrange(_size77):
7608 
            _elem82 = iprot.readI32();
7609 
            self.statuses.append(_elem82)
4801 anupam.sin 7610 
          iprot.readListEnd()
94 ashish 7611 
        else:
7612 
          iprot.skip(ftype)
483 rajveer 7613 
      elif fid == 2:
7614 
        if ftype == TType.I64:
7615 
          self.from_date = iprot.readI64();
94 ashish 7616 
        else:
7617 
          iprot.skip(ftype)
483 rajveer 7618 
      elif fid == 3:
7619 
        if ftype == TType.I64:
7620 
          self.to_date = iprot.readI64();
94 ashish 7621 
        else:
7622 
          iprot.skip(ftype)
483 rajveer 7623 
      elif fid == 4:
94 ashish 7624 
        if ftype == TType.I64:
483 rajveer 7625 
          self.warehouse_id = iprot.readI64();
94 ashish 7626 
        else:
7627 
          iprot.skip(ftype)
7628 
      else:
7629 
        iprot.skip(ftype)
7630 
      iprot.readFieldEnd()
7631 
    iprot.readStructEnd()
7632 
 
7633 
  def write(self, oprot):
7634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7636 
      return
483 rajveer 7637 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 7638 
    if self.statuses is not None:
7639 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7640 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7641 
      for iter83 in self.statuses:
7642 
        oprot.writeI32(iter83)
4801 anupam.sin 7643 
      oprot.writeListEnd()
94 ashish 7644 
      oprot.writeFieldEnd()
3431 rajveer 7645 
    if self.from_date is not None:
483 rajveer 7646 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7647 
      oprot.writeI64(self.from_date)
94 ashish 7648 
      oprot.writeFieldEnd()
3431 rajveer 7649 
    if self.to_date is not None:
483 rajveer 7650 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7651 
      oprot.writeI64(self.to_date)
94 ashish 7652 
      oprot.writeFieldEnd()
3431 rajveer 7653 
    if self.warehouse_id is not None:
483 rajveer 7654 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7655 
      oprot.writeI64(self.warehouse_id)
94 ashish 7656 
      oprot.writeFieldEnd()
7657 
    oprot.writeFieldStop()
7658 
    oprot.writeStructEnd()
7659 
 
3431 rajveer 7660 
  def validate(self):
7661 
    return
7662 
 
7663 
 
94 ashish 7664 
  def __repr__(self):
7665 
    L = ['%s=%r' % (key, value)
7666 
      for key, value in self.__dict__.iteritems()]
7667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7668 
 
7669 
  def __eq__(self, other):
7670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7671 
 
7672 
  def __ne__(self, other):
7673 
    return not (self == other)
7674 
 
483 rajveer 7675 
class getAllOrders_result:
94 ashish 7676 
  """
7677 
  Attributes:
7678 
   - success
7679 
   - ex
7680 
  """
7681 
 
7682 
  thrift_spec = (
483 rajveer 7683 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 7684 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7685 
  )
7686 
 
7687 
  def __init__(self, success=None, ex=None,):
7688 
    self.success = success
7689 
    self.ex = ex
7690 
 
7691 
  def read(self, iprot):
7692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7694 
      return
7695 
    iprot.readStructBegin()
7696 
    while True:
7697 
      (fname, ftype, fid) = iprot.readFieldBegin()
7698 
      if ftype == TType.STOP:
7699 
        break
7700 
      if fid == 0:
483 rajveer 7701 
        if ftype == TType.LIST:
7702 
          self.success = []
5031 varun.gupt 7703 
          (_etype87, _size84) = iprot.readListBegin()
7704 
          for _i88 in xrange(_size84):
7705 
            _elem89 = Order()
7706 
            _elem89.read(iprot)
7707 
            self.success.append(_elem89)
483 rajveer 7708 
          iprot.readListEnd()
94 ashish 7709 
        else:
7710 
          iprot.skip(ftype)
7711 
      elif fid == 1:
7712 
        if ftype == TType.STRUCT:
7713 
          self.ex = TransactionServiceException()
7714 
          self.ex.read(iprot)
7715 
        else:
7716 
          iprot.skip(ftype)
7717 
      else:
7718 
        iprot.skip(ftype)
7719 
      iprot.readFieldEnd()
7720 
    iprot.readStructEnd()
7721 
 
7722 
  def write(self, oprot):
7723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7725 
      return
483 rajveer 7726 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 7727 
    if self.success is not None:
483 rajveer 7728 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7729 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7730 
      for iter90 in self.success:
7731 
        iter90.write(oprot)
483 rajveer 7732 
      oprot.writeListEnd()
94 ashish 7733 
      oprot.writeFieldEnd()
3431 rajveer 7734 
    if self.ex is not None:
94 ashish 7735 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7736 
      self.ex.write(oprot)
7737 
      oprot.writeFieldEnd()
7738 
    oprot.writeFieldStop()
7739 
    oprot.writeStructEnd()
7740 
 
3431 rajveer 7741 
  def validate(self):
7742 
    return
7743 
 
7744 
 
94 ashish 7745 
  def __repr__(self):
7746 
    L = ['%s=%r' % (key, value)
7747 
      for key, value in self.__dict__.iteritems()]
7748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7749 
 
7750 
  def __eq__(self, other):
7751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7752 
 
7753 
  def __ne__(self, other):
7754 
    return not (self == other)
7755 
 
4133 chandransh 7756 
class getOrdersInBatch_args:
7757 
  """
7758 
  Attributes:
7759 
   - statuses
7760 
   - offset
7761 
   - limit
7762 
   - warehouse_id
7763 
  """
7764 
 
7765 
  thrift_spec = (
7766 
    None, # 0
7767 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7768 
    (2, TType.I64, 'offset', None, None, ), # 2
7769 
    (3, TType.I64, 'limit', None, None, ), # 3
7770 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7771 
  )
7772 
 
7773 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
7774 
    self.statuses = statuses
7775 
    self.offset = offset
7776 
    self.limit = limit
7777 
    self.warehouse_id = warehouse_id
7778 
 
7779 
  def read(self, iprot):
7780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7782 
      return
7783 
    iprot.readStructBegin()
7784 
    while True:
7785 
      (fname, ftype, fid) = iprot.readFieldBegin()
7786 
      if ftype == TType.STOP:
7787 
        break
7788 
      if fid == 1:
7789 
        if ftype == TType.LIST:
7790 
          self.statuses = []
5031 varun.gupt 7791 
          (_etype94, _size91) = iprot.readListBegin()
7792 
          for _i95 in xrange(_size91):
7793 
            _elem96 = iprot.readI32();
7794 
            self.statuses.append(_elem96)
4133 chandransh 7795 
          iprot.readListEnd()
7796 
        else:
7797 
          iprot.skip(ftype)
7798 
      elif fid == 2:
7799 
        if ftype == TType.I64:
7800 
          self.offset = iprot.readI64();
7801 
        else:
7802 
          iprot.skip(ftype)
7803 
      elif fid == 3:
7804 
        if ftype == TType.I64:
7805 
          self.limit = iprot.readI64();
7806 
        else:
7807 
          iprot.skip(ftype)
7808 
      elif fid == 4:
7809 
        if ftype == TType.I64:
7810 
          self.warehouse_id = iprot.readI64();
7811 
        else:
7812 
          iprot.skip(ftype)
7813 
      else:
7814 
        iprot.skip(ftype)
7815 
      iprot.readFieldEnd()
7816 
    iprot.readStructEnd()
7817 
 
7818 
  def write(self, oprot):
7819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7821 
      return
7822 
    oprot.writeStructBegin('getOrdersInBatch_args')
7823 
    if self.statuses is not None:
7824 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7825 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7826 
      for iter97 in self.statuses:
7827 
        oprot.writeI32(iter97)
4133 chandransh 7828 
      oprot.writeListEnd()
7829 
      oprot.writeFieldEnd()
7830 
    if self.offset is not None:
7831 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7832 
      oprot.writeI64(self.offset)
7833 
      oprot.writeFieldEnd()
7834 
    if self.limit is not None:
7835 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7836 
      oprot.writeI64(self.limit)
7837 
      oprot.writeFieldEnd()
7838 
    if self.warehouse_id is not None:
7839 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7840 
      oprot.writeI64(self.warehouse_id)
7841 
      oprot.writeFieldEnd()
7842 
    oprot.writeFieldStop()
7843 
    oprot.writeStructEnd()
7844 
 
7845 
  def validate(self):
7846 
    return
7847 
 
7848 
 
7849 
  def __repr__(self):
7850 
    L = ['%s=%r' % (key, value)
7851 
      for key, value in self.__dict__.iteritems()]
7852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7853 
 
7854 
  def __eq__(self, other):
7855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7856 
 
7857 
  def __ne__(self, other):
7858 
    return not (self == other)
7859 
 
7860 
class getOrdersInBatch_result:
7861 
  """
7862 
  Attributes:
7863 
   - success
7864 
   - ex
7865 
  """
7866 
 
7867 
  thrift_spec = (
7868 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7869 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7870 
  )
7871 
 
7872 
  def __init__(self, success=None, ex=None,):
7873 
    self.success = success
7874 
    self.ex = ex
7875 
 
7876 
  def read(self, iprot):
7877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7879 
      return
7880 
    iprot.readStructBegin()
7881 
    while True:
7882 
      (fname, ftype, fid) = iprot.readFieldBegin()
7883 
      if ftype == TType.STOP:
7884 
        break
7885 
      if fid == 0:
7886 
        if ftype == TType.LIST:
7887 
          self.success = []
5031 varun.gupt 7888 
          (_etype101, _size98) = iprot.readListBegin()
7889 
          for _i102 in xrange(_size98):
7890 
            _elem103 = Order()
7891 
            _elem103.read(iprot)
7892 
            self.success.append(_elem103)
4133 chandransh 7893 
          iprot.readListEnd()
7894 
        else:
7895 
          iprot.skip(ftype)
7896 
      elif fid == 1:
7897 
        if ftype == TType.STRUCT:
7898 
          self.ex = TransactionServiceException()
7899 
          self.ex.read(iprot)
7900 
        else:
7901 
          iprot.skip(ftype)
7902 
      else:
7903 
        iprot.skip(ftype)
7904 
      iprot.readFieldEnd()
7905 
    iprot.readStructEnd()
7906 
 
7907 
  def write(self, oprot):
7908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7910 
      return
7911 
    oprot.writeStructBegin('getOrdersInBatch_result')
7912 
    if self.success is not None:
7913 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7914 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7915 
      for iter104 in self.success:
7916 
        iter104.write(oprot)
4133 chandransh 7917 
      oprot.writeListEnd()
7918 
      oprot.writeFieldEnd()
7919 
    if self.ex is not None:
7920 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7921 
      self.ex.write(oprot)
7922 
      oprot.writeFieldEnd()
7923 
    oprot.writeFieldStop()
7924 
    oprot.writeStructEnd()
7925 
 
7926 
  def validate(self):
7927 
    return
7928 
 
7929 
 
7930 
  def __repr__(self):
7931 
    L = ['%s=%r' % (key, value)
7932 
      for key, value in self.__dict__.iteritems()]
7933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7934 
 
7935 
  def __eq__(self, other):
7936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7937 
 
7938 
  def __ne__(self, other):
7939 
    return not (self == other)
7940 
 
7941 
class getOrderCount_args:
7942 
  """
7943 
  Attributes:
7944 
   - statuses
7945 
   - warehouseId
7946 
  """
7947 
 
7948 
  thrift_spec = (
7949 
    None, # 0
7950 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7951 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7952 
  )
7953 
 
7954 
  def __init__(self, statuses=None, warehouseId=None,):
7955 
    self.statuses = statuses
7956 
    self.warehouseId = warehouseId
7957 
 
7958 
  def read(self, iprot):
7959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7961 
      return
7962 
    iprot.readStructBegin()
7963 
    while True:
7964 
      (fname, ftype, fid) = iprot.readFieldBegin()
7965 
      if ftype == TType.STOP:
7966 
        break
7967 
      if fid == 1:
7968 
        if ftype == TType.LIST:
7969 
          self.statuses = []
5031 varun.gupt 7970 
          (_etype108, _size105) = iprot.readListBegin()
7971 
          for _i109 in xrange(_size105):
7972 
            _elem110 = iprot.readI32();
7973 
            self.statuses.append(_elem110)
4133 chandransh 7974 
          iprot.readListEnd()
7975 
        else:
7976 
          iprot.skip(ftype)
7977 
      elif fid == 2:
7978 
        if ftype == TType.I64:
7979 
          self.warehouseId = iprot.readI64();
7980 
        else:
7981 
          iprot.skip(ftype)
7982 
      else:
7983 
        iprot.skip(ftype)
7984 
      iprot.readFieldEnd()
7985 
    iprot.readStructEnd()
7986 
 
7987 
  def write(self, oprot):
7988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7990 
      return
7991 
    oprot.writeStructBegin('getOrderCount_args')
7992 
    if self.statuses is not None:
7993 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7994 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7995 
      for iter111 in self.statuses:
7996 
        oprot.writeI32(iter111)
4133 chandransh 7997 
      oprot.writeListEnd()
7998 
      oprot.writeFieldEnd()
7999 
    if self.warehouseId is not None:
8000 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8001 
      oprot.writeI64(self.warehouseId)
8002 
      oprot.writeFieldEnd()
8003 
    oprot.writeFieldStop()
8004 
    oprot.writeStructEnd()
8005 
 
8006 
  def validate(self):
8007 
    return
8008 
 
8009 
 
8010 
  def __repr__(self):
8011 
    L = ['%s=%r' % (key, value)
8012 
      for key, value in self.__dict__.iteritems()]
8013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8014 
 
8015 
  def __eq__(self, other):
8016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8017 
 
8018 
  def __ne__(self, other):
8019 
    return not (self == other)
8020 
 
8021 
class getOrderCount_result:
8022 
  """
8023 
  Attributes:
8024 
   - success
8025 
   - ex
8026 
  """
8027 
 
8028 
  thrift_spec = (
8029 
    (0, TType.I32, 'success', None, None, ), # 0
8030 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8031 
  )
8032 
 
8033 
  def __init__(self, success=None, ex=None,):
8034 
    self.success = success
8035 
    self.ex = ex
8036 
 
8037 
  def read(self, iprot):
8038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8040 
      return
8041 
    iprot.readStructBegin()
8042 
    while True:
8043 
      (fname, ftype, fid) = iprot.readFieldBegin()
8044 
      if ftype == TType.STOP:
8045 
        break
8046 
      if fid == 0:
8047 
        if ftype == TType.I32:
8048 
          self.success = iprot.readI32();
8049 
        else:
8050 
          iprot.skip(ftype)
8051 
      elif fid == 1:
8052 
        if ftype == TType.STRUCT:
8053 
          self.ex = TransactionServiceException()
8054 
          self.ex.read(iprot)
8055 
        else:
8056 
          iprot.skip(ftype)
8057 
      else:
8058 
        iprot.skip(ftype)
8059 
      iprot.readFieldEnd()
8060 
    iprot.readStructEnd()
8061 
 
8062 
  def write(self, oprot):
8063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8065 
      return
8066 
    oprot.writeStructBegin('getOrderCount_result')
8067 
    if self.success is not None:
8068 
      oprot.writeFieldBegin('success', TType.I32, 0)
8069 
      oprot.writeI32(self.success)
8070 
      oprot.writeFieldEnd()
8071 
    if self.ex is not None:
8072 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8073 
      self.ex.write(oprot)
8074 
      oprot.writeFieldEnd()
8075 
    oprot.writeFieldStop()
8076 
    oprot.writeStructEnd()
8077 
 
8078 
  def validate(self):
8079 
    return
8080 
 
8081 
 
8082 
  def __repr__(self):
8083 
    L = ['%s=%r' % (key, value)
8084 
      for key, value in self.__dict__.iteritems()]
8085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8086 
 
8087 
  def __eq__(self, other):
8088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8089 
 
8090 
  def __ne__(self, other):
8091 
    return not (self == other)
8092 
 
999 varun.gupt 8093 
class getOrdersByBillingDate_args:
8094 
  """
8095 
  Attributes:
8096 
   - status
8097 
   - start_billing_date
8098 
   - end_billing_date
8099 
   - warehouse_id
8100 
  """
8101 
 
8102 
  thrift_spec = (
8103 
    None, # 0
8104 
    (1, TType.I32, 'status', None, None, ), # 1
8105 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
8106 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
8107 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8108 
  )
8109 
 
8110 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
8111 
    self.status = status
8112 
    self.start_billing_date = start_billing_date
8113 
    self.end_billing_date = end_billing_date
8114 
    self.warehouse_id = warehouse_id
8115 
 
8116 
  def read(self, iprot):
8117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8119 
      return
8120 
    iprot.readStructBegin()
8121 
    while True:
8122 
      (fname, ftype, fid) = iprot.readFieldBegin()
8123 
      if ftype == TType.STOP:
8124 
        break
8125 
      if fid == 1:
8126 
        if ftype == TType.I32:
8127 
          self.status = iprot.readI32();
8128 
        else:
8129 
          iprot.skip(ftype)
8130 
      elif fid == 2:
8131 
        if ftype == TType.I64:
8132 
          self.start_billing_date = iprot.readI64();
8133 
        else:
8134 
          iprot.skip(ftype)
8135 
      elif fid == 3:
8136 
        if ftype == TType.I64:
8137 
          self.end_billing_date = iprot.readI64();
8138 
        else:
8139 
          iprot.skip(ftype)
8140 
      elif fid == 4:
8141 
        if ftype == TType.I64:
8142 
          self.warehouse_id = iprot.readI64();
8143 
        else:
8144 
          iprot.skip(ftype)
8145 
      else:
8146 
        iprot.skip(ftype)
8147 
      iprot.readFieldEnd()
8148 
    iprot.readStructEnd()
8149 
 
8150 
  def write(self, oprot):
8151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8153 
      return
8154 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 8155 
    if self.status is not None:
999 varun.gupt 8156 
      oprot.writeFieldBegin('status', TType.I32, 1)
8157 
      oprot.writeI32(self.status)
8158 
      oprot.writeFieldEnd()
3431 rajveer 8159 
    if self.start_billing_date is not None:
999 varun.gupt 8160 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
8161 
      oprot.writeI64(self.start_billing_date)
8162 
      oprot.writeFieldEnd()
3431 rajveer 8163 
    if self.end_billing_date is not None:
999 varun.gupt 8164 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
8165 
      oprot.writeI64(self.end_billing_date)
8166 
      oprot.writeFieldEnd()
3431 rajveer 8167 
    if self.warehouse_id is not None:
999 varun.gupt 8168 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8169 
      oprot.writeI64(self.warehouse_id)
8170 
      oprot.writeFieldEnd()
8171 
    oprot.writeFieldStop()
8172 
    oprot.writeStructEnd()
8173 
 
3431 rajveer 8174 
  def validate(self):
8175 
    return
8176 
 
8177 
 
999 varun.gupt 8178 
  def __repr__(self):
8179 
    L = ['%s=%r' % (key, value)
8180 
      for key, value in self.__dict__.iteritems()]
8181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8182 
 
8183 
  def __eq__(self, other):
8184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8185 
 
8186 
  def __ne__(self, other):
8187 
    return not (self == other)
8188 
 
8189 
class getOrdersByBillingDate_result:
8190 
  """
8191 
  Attributes:
8192 
   - success
8193 
   - ex
8194 
  """
8195 
 
8196 
  thrift_spec = (
8197 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8198 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8199 
  )
8200 
 
8201 
  def __init__(self, success=None, ex=None,):
8202 
    self.success = success
8203 
    self.ex = ex
8204 
 
8205 
  def read(self, iprot):
8206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8208 
      return
8209 
    iprot.readStructBegin()
8210 
    while True:
8211 
      (fname, ftype, fid) = iprot.readFieldBegin()
8212 
      if ftype == TType.STOP:
8213 
        break
8214 
      if fid == 0:
8215 
        if ftype == TType.LIST:
8216 
          self.success = []
5031 varun.gupt 8217 
          (_etype115, _size112) = iprot.readListBegin()
8218 
          for _i116 in xrange(_size112):
8219 
            _elem117 = Order()
8220 
            _elem117.read(iprot)
8221 
            self.success.append(_elem117)
999 varun.gupt 8222 
          iprot.readListEnd()
8223 
        else:
8224 
          iprot.skip(ftype)
8225 
      elif fid == 1:
8226 
        if ftype == TType.STRUCT:
8227 
          self.ex = TransactionServiceException()
8228 
          self.ex.read(iprot)
8229 
        else:
8230 
          iprot.skip(ftype)
8231 
      else:
8232 
        iprot.skip(ftype)
8233 
      iprot.readFieldEnd()
8234 
    iprot.readStructEnd()
8235 
 
8236 
  def write(self, oprot):
8237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8239 
      return
8240 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 8241 
    if self.success is not None:
999 varun.gupt 8242 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8243 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8244 
      for iter118 in self.success:
8245 
        iter118.write(oprot)
999 varun.gupt 8246 
      oprot.writeListEnd()
8247 
      oprot.writeFieldEnd()
3431 rajveer 8248 
    if self.ex is not None:
999 varun.gupt 8249 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8250 
      self.ex.write(oprot)
8251 
      oprot.writeFieldEnd()
8252 
    oprot.writeFieldStop()
8253 
    oprot.writeStructEnd()
8254 
 
3431 rajveer 8255 
  def validate(self):
8256 
    return
8257 
 
8258 
 
999 varun.gupt 8259 
  def __repr__(self):
8260 
    L = ['%s=%r' % (key, value)
8261 
      for key, value in self.__dict__.iteritems()]
8262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8263 
 
8264 
  def __eq__(self, other):
8265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8266 
 
8267 
  def __ne__(self, other):
8268 
    return not (self == other)
8269 
 
3427 chandransh 8270 
class getOrdersByShippingDate_args:
8271 
  """
8272 
  Attributes:
8273 
   - fromShippingDate
8274 
   - toShippingDate
8275 
   - providerId
8276 
   - warehouseId
3451 chandransh 8277 
   - cod
3427 chandransh 8278 
  """
8279 
 
8280 
  thrift_spec = (
8281 
    None, # 0
8282 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
8283 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
8284 
    (3, TType.I64, 'providerId', None, None, ), # 3
8285 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 8286 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 8287 
  )
8288 
 
3451 chandransh 8289 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 8290 
    self.fromShippingDate = fromShippingDate
8291 
    self.toShippingDate = toShippingDate
8292 
    self.providerId = providerId
8293 
    self.warehouseId = warehouseId
3451 chandransh 8294 
    self.cod = cod
3427 chandransh 8295 
 
8296 
  def read(self, iprot):
8297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8299 
      return
8300 
    iprot.readStructBegin()
8301 
    while True:
8302 
      (fname, ftype, fid) = iprot.readFieldBegin()
8303 
      if ftype == TType.STOP:
8304 
        break
8305 
      if fid == 1:
8306 
        if ftype == TType.I64:
8307 
          self.fromShippingDate = iprot.readI64();
8308 
        else:
8309 
          iprot.skip(ftype)
8310 
      elif fid == 2:
8311 
        if ftype == TType.I64:
8312 
          self.toShippingDate = iprot.readI64();
8313 
        else:
8314 
          iprot.skip(ftype)
8315 
      elif fid == 3:
8316 
        if ftype == TType.I64:
8317 
          self.providerId = iprot.readI64();
8318 
        else:
8319 
          iprot.skip(ftype)
8320 
      elif fid == 4:
8321 
        if ftype == TType.I64:
8322 
          self.warehouseId = iprot.readI64();
8323 
        else:
8324 
          iprot.skip(ftype)
3451 chandransh 8325 
      elif fid == 5:
8326 
        if ftype == TType.BOOL:
8327 
          self.cod = iprot.readBool();
8328 
        else:
8329 
          iprot.skip(ftype)
3427 chandransh 8330 
      else:
8331 
        iprot.skip(ftype)
8332 
      iprot.readFieldEnd()
8333 
    iprot.readStructEnd()
8334 
 
8335 
  def write(self, oprot):
8336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8338 
      return
8339 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 8340 
    if self.fromShippingDate is not None:
3427 chandransh 8341 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
8342 
      oprot.writeI64(self.fromShippingDate)
8343 
      oprot.writeFieldEnd()
3431 rajveer 8344 
    if self.toShippingDate is not None:
3427 chandransh 8345 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
8346 
      oprot.writeI64(self.toShippingDate)
8347 
      oprot.writeFieldEnd()
3431 rajveer 8348 
    if self.providerId is not None:
3427 chandransh 8349 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
8350 
      oprot.writeI64(self.providerId)
8351 
      oprot.writeFieldEnd()
3431 rajveer 8352 
    if self.warehouseId is not None:
3427 chandransh 8353 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
8354 
      oprot.writeI64(self.warehouseId)
8355 
      oprot.writeFieldEnd()
3451 chandransh 8356 
    if self.cod is not None:
8357 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
8358 
      oprot.writeBool(self.cod)
8359 
      oprot.writeFieldEnd()
3427 chandransh 8360 
    oprot.writeFieldStop()
8361 
    oprot.writeStructEnd()
8362 
 
3431 rajveer 8363 
  def validate(self):
8364 
    return
8365 
 
8366 
 
3427 chandransh 8367 
  def __repr__(self):
8368 
    L = ['%s=%r' % (key, value)
8369 
      for key, value in self.__dict__.iteritems()]
8370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8371 
 
8372 
  def __eq__(self, other):
8373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8374 
 
8375 
  def __ne__(self, other):
8376 
    return not (self == other)
8377 
 
8378 
class getOrdersByShippingDate_result:
8379 
  """
8380 
  Attributes:
8381 
   - success
8382 
   - ex
8383 
  """
8384 
 
8385 
  thrift_spec = (
8386 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8387 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8388 
  )
8389 
 
8390 
  def __init__(self, success=None, ex=None,):
8391 
    self.success = success
8392 
    self.ex = ex
8393 
 
8394 
  def read(self, iprot):
8395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8397 
      return
8398 
    iprot.readStructBegin()
8399 
    while True:
8400 
      (fname, ftype, fid) = iprot.readFieldBegin()
8401 
      if ftype == TType.STOP:
8402 
        break
8403 
      if fid == 0:
8404 
        if ftype == TType.LIST:
8405 
          self.success = []
5031 varun.gupt 8406 
          (_etype122, _size119) = iprot.readListBegin()
8407 
          for _i123 in xrange(_size119):
8408 
            _elem124 = Order()
8409 
            _elem124.read(iprot)
8410 
            self.success.append(_elem124)
3427 chandransh 8411 
          iprot.readListEnd()
8412 
        else:
8413 
          iprot.skip(ftype)
8414 
      elif fid == 1:
8415 
        if ftype == TType.STRUCT:
8416 
          self.ex = TransactionServiceException()
8417 
          self.ex.read(iprot)
8418 
        else:
8419 
          iprot.skip(ftype)
8420 
      else:
8421 
        iprot.skip(ftype)
8422 
      iprot.readFieldEnd()
8423 
    iprot.readStructEnd()
8424 
 
8425 
  def write(self, oprot):
8426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8428 
      return
8429 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 8430 
    if self.success is not None:
3427 chandransh 8431 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8432 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8433 
      for iter125 in self.success:
8434 
        iter125.write(oprot)
3427 chandransh 8435 
      oprot.writeListEnd()
8436 
      oprot.writeFieldEnd()
3431 rajveer 8437 
    if self.ex is not None:
3427 chandransh 8438 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8439 
      self.ex.write(oprot)
8440 
      oprot.writeFieldEnd()
8441 
    oprot.writeFieldStop()
8442 
    oprot.writeStructEnd()
8443 
 
3431 rajveer 8444 
  def validate(self):
8445 
    return
8446 
 
8447 
 
3427 chandransh 8448 
  def __repr__(self):
8449 
    L = ['%s=%r' % (key, value)
8450 
      for key, value in self.__dict__.iteritems()]
8451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8452 
 
8453 
  def __eq__(self, other):
8454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8455 
 
8456 
  def __ne__(self, other):
8457 
    return not (self == other)
8458 
 
1382 varun.gupt 8459 
class getReturnableOrdersForCustomer_args:
8460 
  """
8461 
  Attributes:
8462 
   - customer_id
8463 
   - limit
8464 
  """
8465 
 
8466 
  thrift_spec = (
8467 
    None, # 0
8468 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8469 
    (2, TType.I64, 'limit', None, None, ), # 2
8470 
  )
8471 
 
8472 
  def __init__(self, customer_id=None, limit=None,):
8473 
    self.customer_id = customer_id
8474 
    self.limit = limit
8475 
 
8476 
  def read(self, iprot):
8477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8479 
      return
8480 
    iprot.readStructBegin()
8481 
    while True:
8482 
      (fname, ftype, fid) = iprot.readFieldBegin()
8483 
      if ftype == TType.STOP:
8484 
        break
8485 
      if fid == 1:
8486 
        if ftype == TType.I64:
8487 
          self.customer_id = iprot.readI64();
8488 
        else:
8489 
          iprot.skip(ftype)
8490 
      elif fid == 2:
8491 
        if ftype == TType.I64:
8492 
          self.limit = iprot.readI64();
8493 
        else:
8494 
          iprot.skip(ftype)
8495 
      else:
8496 
        iprot.skip(ftype)
8497 
      iprot.readFieldEnd()
8498 
    iprot.readStructEnd()
8499 
 
8500 
  def write(self, oprot):
8501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8503 
      return
8504 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 8505 
    if self.customer_id is not None:
1382 varun.gupt 8506 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8507 
      oprot.writeI64(self.customer_id)
8508 
      oprot.writeFieldEnd()
3431 rajveer 8509 
    if self.limit is not None:
1382 varun.gupt 8510 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8511 
      oprot.writeI64(self.limit)
8512 
      oprot.writeFieldEnd()
8513 
    oprot.writeFieldStop()
8514 
    oprot.writeStructEnd()
8515 
 
3431 rajveer 8516 
  def validate(self):
8517 
    return
8518 
 
8519 
 
1382 varun.gupt 8520 
  def __repr__(self):
8521 
    L = ['%s=%r' % (key, value)
8522 
      for key, value in self.__dict__.iteritems()]
8523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8524 
 
8525 
  def __eq__(self, other):
8526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8527 
 
8528 
  def __ne__(self, other):
8529 
    return not (self == other)
8530 
 
8531 
class getReturnableOrdersForCustomer_result:
8532 
  """
8533 
  Attributes:
8534 
   - success
8535 
   - ex
8536 
  """
8537 
 
8538 
  thrift_spec = (
8539 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8540 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8541 
  )
8542 
 
8543 
  def __init__(self, success=None, ex=None,):
8544 
    self.success = success
8545 
    self.ex = ex
8546 
 
8547 
  def read(self, iprot):
8548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8550 
      return
8551 
    iprot.readStructBegin()
8552 
    while True:
8553 
      (fname, ftype, fid) = iprot.readFieldBegin()
8554 
      if ftype == TType.STOP:
8555 
        break
8556 
      if fid == 0:
8557 
        if ftype == TType.LIST:
8558 
          self.success = []
5031 varun.gupt 8559 
          (_etype129, _size126) = iprot.readListBegin()
8560 
          for _i130 in xrange(_size126):
8561 
            _elem131 = iprot.readI64();
8562 
            self.success.append(_elem131)
1382 varun.gupt 8563 
          iprot.readListEnd()
8564 
        else:
8565 
          iprot.skip(ftype)
8566 
      elif fid == 1:
8567 
        if ftype == TType.STRUCT:
8568 
          self.ex = TransactionServiceException()
8569 
          self.ex.read(iprot)
8570 
        else:
8571 
          iprot.skip(ftype)
8572 
      else:
8573 
        iprot.skip(ftype)
8574 
      iprot.readFieldEnd()
8575 
    iprot.readStructEnd()
8576 
 
8577 
  def write(self, oprot):
8578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8580 
      return
8581 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 8582 
    if self.success is not None:
1382 varun.gupt 8583 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8584 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8585 
      for iter132 in self.success:
8586 
        oprot.writeI64(iter132)
1382 varun.gupt 8587 
      oprot.writeListEnd()
8588 
      oprot.writeFieldEnd()
3431 rajveer 8589 
    if self.ex is not None:
1382 varun.gupt 8590 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8591 
      self.ex.write(oprot)
8592 
      oprot.writeFieldEnd()
8593 
    oprot.writeFieldStop()
8594 
    oprot.writeStructEnd()
8595 
 
3431 rajveer 8596 
  def validate(self):
8597 
    return
8598 
 
8599 
 
1382 varun.gupt 8600 
  def __repr__(self):
8601 
    L = ['%s=%r' % (key, value)
8602 
      for key, value in self.__dict__.iteritems()]
8603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8604 
 
8605 
  def __eq__(self, other):
8606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8607 
 
8608 
  def __ne__(self, other):
8609 
    return not (self == other)
8610 
 
8611 
class getCancellableOrdersForCustomer_args:
8612 
  """
8613 
  Attributes:
8614 
   - customer_id
8615 
   - limit
8616 
  """
8617 
 
8618 
  thrift_spec = (
8619 
    None, # 0
8620 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8621 
    (2, TType.I64, 'limit', None, None, ), # 2
8622 
  )
8623 
 
8624 
  def __init__(self, customer_id=None, limit=None,):
8625 
    self.customer_id = customer_id
8626 
    self.limit = limit
8627 
 
8628 
  def read(self, iprot):
8629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8631 
      return
8632 
    iprot.readStructBegin()
8633 
    while True:
8634 
      (fname, ftype, fid) = iprot.readFieldBegin()
8635 
      if ftype == TType.STOP:
8636 
        break
8637 
      if fid == 1:
8638 
        if ftype == TType.I64:
8639 
          self.customer_id = iprot.readI64();
8640 
        else:
8641 
          iprot.skip(ftype)
8642 
      elif fid == 2:
8643 
        if ftype == TType.I64:
8644 
          self.limit = iprot.readI64();
8645 
        else:
8646 
          iprot.skip(ftype)
8647 
      else:
8648 
        iprot.skip(ftype)
8649 
      iprot.readFieldEnd()
8650 
    iprot.readStructEnd()
8651 
 
8652 
  def write(self, oprot):
8653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8655 
      return
8656 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 8657 
    if self.customer_id is not None:
1382 varun.gupt 8658 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8659 
      oprot.writeI64(self.customer_id)
8660 
      oprot.writeFieldEnd()
3431 rajveer 8661 
    if self.limit is not None:
1382 varun.gupt 8662 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8663 
      oprot.writeI64(self.limit)
8664 
      oprot.writeFieldEnd()
8665 
    oprot.writeFieldStop()
8666 
    oprot.writeStructEnd()
8667 
 
3431 rajveer 8668 
  def validate(self):
8669 
    return
8670 
 
8671 
 
1382 varun.gupt 8672 
  def __repr__(self):
8673 
    L = ['%s=%r' % (key, value)
8674 
      for key, value in self.__dict__.iteritems()]
8675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8676 
 
8677 
  def __eq__(self, other):
8678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8679 
 
8680 
  def __ne__(self, other):
8681 
    return not (self == other)
8682 
 
8683 
class getCancellableOrdersForCustomer_result:
8684 
  """
8685 
  Attributes:
8686 
   - success
8687 
   - ex
8688 
  """
8689 
 
8690 
  thrift_spec = (
8691 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8692 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8693 
  )
8694 
 
8695 
  def __init__(self, success=None, ex=None,):
8696 
    self.success = success
8697 
    self.ex = ex
8698 
 
8699 
  def read(self, iprot):
8700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8702 
      return
8703 
    iprot.readStructBegin()
8704 
    while True:
8705 
      (fname, ftype, fid) = iprot.readFieldBegin()
8706 
      if ftype == TType.STOP:
8707 
        break
8708 
      if fid == 0:
8709 
        if ftype == TType.LIST:
8710 
          self.success = []
5031 varun.gupt 8711 
          (_etype136, _size133) = iprot.readListBegin()
8712 
          for _i137 in xrange(_size133):
8713 
            _elem138 = iprot.readI64();
8714 
            self.success.append(_elem138)
1382 varun.gupt 8715 
          iprot.readListEnd()
8716 
        else:
8717 
          iprot.skip(ftype)
8718 
      elif fid == 1:
8719 
        if ftype == TType.STRUCT:
8720 
          self.ex = TransactionServiceException()
8721 
          self.ex.read(iprot)
8722 
        else:
8723 
          iprot.skip(ftype)
8724 
      else:
8725 
        iprot.skip(ftype)
8726 
      iprot.readFieldEnd()
8727 
    iprot.readStructEnd()
8728 
 
8729 
  def write(self, oprot):
8730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8732 
      return
8733 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 8734 
    if self.success is not None:
1382 varun.gupt 8735 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8736 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8737 
      for iter139 in self.success:
8738 
        oprot.writeI64(iter139)
1382 varun.gupt 8739 
      oprot.writeListEnd()
8740 
      oprot.writeFieldEnd()
3431 rajveer 8741 
    if self.ex is not None:
1382 varun.gupt 8742 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8743 
      self.ex.write(oprot)
8744 
      oprot.writeFieldEnd()
8745 
    oprot.writeFieldStop()
8746 
    oprot.writeStructEnd()
8747 
 
3431 rajveer 8748 
  def validate(self):
8749 
    return
8750 
 
8751 
 
1382 varun.gupt 8752 
  def __repr__(self):
8753 
    L = ['%s=%r' % (key, value)
8754 
      for key, value in self.__dict__.iteritems()]
8755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8756 
 
8757 
  def __eq__(self, other):
8758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8759 
 
8760 
  def __ne__(self, other):
8761 
    return not (self == other)
8762 
 
483 rajveer 8763 
class changeOrderStatus_args:
94 ashish 8764 
  """
8765 
  Attributes:
483 rajveer 8766 
   - orderId
8767 
   - status
8768 
   - description
94 ashish 8769 
  """
8770 
 
8771 
  thrift_spec = (
8772 
    None, # 0
483 rajveer 8773 
    (1, TType.I64, 'orderId', None, None, ), # 1
8774 
    (2, TType.I32, 'status', None, None, ), # 2
8775 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8776 
  )
8777 
 
483 rajveer 8778 
  def __init__(self, orderId=None, status=None, description=None,):
8779 
    self.orderId = orderId
8780 
    self.status = status
8781 
    self.description = description
94 ashish 8782 
 
8783 
  def read(self, iprot):
8784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8786 
      return
8787 
    iprot.readStructBegin()
8788 
    while True:
8789 
      (fname, ftype, fid) = iprot.readFieldBegin()
8790 
      if ftype == TType.STOP:
8791 
        break
8792 
      if fid == 1:
8793 
        if ftype == TType.I64:
483 rajveer 8794 
          self.orderId = iprot.readI64();
94 ashish 8795 
        else:
8796 
          iprot.skip(ftype)
8797 
      elif fid == 2:
483 rajveer 8798 
        if ftype == TType.I32:
8799 
          self.status = iprot.readI32();
94 ashish 8800 
        else:
8801 
          iprot.skip(ftype)
483 rajveer 8802 
      elif fid == 3:
8803 
        if ftype == TType.STRING:
8804 
          self.description = iprot.readString();
8805 
        else:
8806 
          iprot.skip(ftype)
94 ashish 8807 
      else:
8808 
        iprot.skip(ftype)
8809 
      iprot.readFieldEnd()
8810 
    iprot.readStructEnd()
8811 
 
8812 
  def write(self, oprot):
8813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8815 
      return
483 rajveer 8816 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 8817 
    if self.orderId is not None:
483 rajveer 8818 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8819 
      oprot.writeI64(self.orderId)
94 ashish 8820 
      oprot.writeFieldEnd()
3431 rajveer 8821 
    if self.status is not None:
483 rajveer 8822 
      oprot.writeFieldBegin('status', TType.I32, 2)
8823 
      oprot.writeI32(self.status)
94 ashish 8824 
      oprot.writeFieldEnd()
3431 rajveer 8825 
    if self.description is not None:
483 rajveer 8826 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8827 
      oprot.writeString(self.description)
8828 
      oprot.writeFieldEnd()
94 ashish 8829 
    oprot.writeFieldStop()
8830 
    oprot.writeStructEnd()
8831 
 
3431 rajveer 8832 
  def validate(self):
8833 
    return
8834 
 
8835 
 
94 ashish 8836 
  def __repr__(self):
8837 
    L = ['%s=%r' % (key, value)
8838 
      for key, value in self.__dict__.iteritems()]
8839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8840 
 
8841 
  def __eq__(self, other):
8842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8843 
 
8844 
  def __ne__(self, other):
8845 
    return not (self == other)
8846 
 
483 rajveer 8847 
class changeOrderStatus_result:
94 ashish 8848 
  """
8849 
  Attributes:
8850 
   - success
8851 
   - ex
8852 
  """
8853 
 
8854 
  thrift_spec = (
8855 
    (0, TType.BOOL, 'success', None, None, ), # 0
8856 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8857 
  )
8858 
 
8859 
  def __init__(self, success=None, ex=None,):
8860 
    self.success = success
8861 
    self.ex = ex
8862 
 
8863 
  def read(self, iprot):
8864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8866 
      return
8867 
    iprot.readStructBegin()
8868 
    while True:
8869 
      (fname, ftype, fid) = iprot.readFieldBegin()
8870 
      if ftype == TType.STOP:
8871 
        break
8872 
      if fid == 0:
8873 
        if ftype == TType.BOOL:
8874 
          self.success = iprot.readBool();
8875 
        else:
8876 
          iprot.skip(ftype)
8877 
      elif fid == 1:
8878 
        if ftype == TType.STRUCT:
8879 
          self.ex = TransactionServiceException()
8880 
          self.ex.read(iprot)
8881 
        else:
8882 
          iprot.skip(ftype)
8883 
      else:
8884 
        iprot.skip(ftype)
8885 
      iprot.readFieldEnd()
8886 
    iprot.readStructEnd()
8887 
 
8888 
  def write(self, oprot):
8889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8891 
      return
483 rajveer 8892 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 8893 
    if self.success is not None:
94 ashish 8894 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8895 
      oprot.writeBool(self.success)
8896 
      oprot.writeFieldEnd()
3431 rajveer 8897 
    if self.ex is not None:
94 ashish 8898 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8899 
      self.ex.write(oprot)
8900 
      oprot.writeFieldEnd()
8901 
    oprot.writeFieldStop()
8902 
    oprot.writeStructEnd()
8903 
 
3431 rajveer 8904 
  def validate(self):
8905 
    return
8906 
 
8907 
 
94 ashish 8908 
  def __repr__(self):
8909 
    L = ['%s=%r' % (key, value)
8910 
      for key, value in self.__dict__.iteritems()]
8911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8912 
 
8913 
  def __eq__(self, other):
8914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8915 
 
8916 
  def __ne__(self, other):
8917 
    return not (self == other)
8918 
 
3064 chandransh 8919 
class getOrdersForTransaction_args:
494 rajveer 8920 
  """
8921 
  Attributes:
3064 chandransh 8922 
   - transactionId
8923 
   - customerId
494 rajveer 8924 
  """
8925 
 
8926 
  thrift_spec = (
8927 
    None, # 0
3064 chandransh 8928 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8929 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 8930 
  )
8931 
 
3064 chandransh 8932 
  def __init__(self, transactionId=None, customerId=None,):
8933 
    self.transactionId = transactionId
8934 
    self.customerId = customerId
494 rajveer 8935 
 
8936 
  def read(self, iprot):
8937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8939 
      return
8940 
    iprot.readStructBegin()
8941 
    while True:
8942 
      (fname, ftype, fid) = iprot.readFieldBegin()
8943 
      if ftype == TType.STOP:
8944 
        break
8945 
      if fid == 1:
8946 
        if ftype == TType.I64:
3064 chandransh 8947 
          self.transactionId = iprot.readI64();
494 rajveer 8948 
        else:
8949 
          iprot.skip(ftype)
8950 
      elif fid == 2:
3064 chandransh 8951 
        if ftype == TType.I64:
8952 
          self.customerId = iprot.readI64();
494 rajveer 8953 
        else:
8954 
          iprot.skip(ftype)
8955 
      else:
8956 
        iprot.skip(ftype)
8957 
      iprot.readFieldEnd()
8958 
    iprot.readStructEnd()
8959 
 
8960 
  def write(self, oprot):
8961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8963 
      return
3064 chandransh 8964 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 8965 
    if self.transactionId is not None:
3064 chandransh 8966 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8967 
      oprot.writeI64(self.transactionId)
494 rajveer 8968 
      oprot.writeFieldEnd()
3431 rajveer 8969 
    if self.customerId is not None:
3064 chandransh 8970 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
8971 
      oprot.writeI64(self.customerId)
494 rajveer 8972 
      oprot.writeFieldEnd()
8973 
    oprot.writeFieldStop()
8974 
    oprot.writeStructEnd()
8975 
 
3431 rajveer 8976 
  def validate(self):
8977 
    return
8978 
 
8979 
 
494 rajveer 8980 
  def __repr__(self):
8981 
    L = ['%s=%r' % (key, value)
8982 
      for key, value in self.__dict__.iteritems()]
8983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8984 
 
8985 
  def __eq__(self, other):
8986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8987 
 
8988 
  def __ne__(self, other):
8989 
    return not (self == other)
8990 
 
3064 chandransh 8991 
class getOrdersForTransaction_result:
494 rajveer 8992 
  """
8993 
  Attributes:
8994 
   - success
8995 
   - ex
8996 
  """
8997 
 
8998 
  thrift_spec = (
3064 chandransh 8999 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 9000 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9001 
  )
9002 
 
9003 
  def __init__(self, success=None, ex=None,):
9004 
    self.success = success
9005 
    self.ex = ex
9006 
 
9007 
  def read(self, iprot):
9008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9010 
      return
9011 
    iprot.readStructBegin()
9012 
    while True:
9013 
      (fname, ftype, fid) = iprot.readFieldBegin()
9014 
      if ftype == TType.STOP:
9015 
        break
9016 
      if fid == 0:
3064 chandransh 9017 
        if ftype == TType.LIST:
9018 
          self.success = []
5031 varun.gupt 9019 
          (_etype143, _size140) = iprot.readListBegin()
9020 
          for _i144 in xrange(_size140):
9021 
            _elem145 = Order()
9022 
            _elem145.read(iprot)
9023 
            self.success.append(_elem145)
3064 chandransh 9024 
          iprot.readListEnd()
494 rajveer 9025 
        else:
9026 
          iprot.skip(ftype)
9027 
      elif fid == 1:
9028 
        if ftype == TType.STRUCT:
9029 
          self.ex = TransactionServiceException()
9030 
          self.ex.read(iprot)
9031 
        else:
9032 
          iprot.skip(ftype)
9033 
      else:
9034 
        iprot.skip(ftype)
9035 
      iprot.readFieldEnd()
9036 
    iprot.readStructEnd()
9037 
 
9038 
  def write(self, oprot):
9039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9041 
      return
3064 chandransh 9042 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 9043 
    if self.success is not None:
3064 chandransh 9044 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9045 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9046 
      for iter146 in self.success:
9047 
        iter146.write(oprot)
3064 chandransh 9048 
      oprot.writeListEnd()
494 rajveer 9049 
      oprot.writeFieldEnd()
3431 rajveer 9050 
    if self.ex is not None:
494 rajveer 9051 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9052 
      self.ex.write(oprot)
9053 
      oprot.writeFieldEnd()
9054 
    oprot.writeFieldStop()
9055 
    oprot.writeStructEnd()
9056 
 
3431 rajveer 9057 
  def validate(self):
9058 
    return
9059 
 
9060 
 
494 rajveer 9061 
  def __repr__(self):
9062 
    L = ['%s=%r' % (key, value)
9063 
      for key, value in self.__dict__.iteritems()]
9064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9065 
 
9066 
  def __eq__(self, other):
9067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9068 
 
9069 
  def __ne__(self, other):
9070 
    return not (self == other)
9071 
 
3064 chandransh 9072 
class getOrdersForCustomer_args:
1149 chandransh 9073 
  """
9074 
  Attributes:
3064 chandransh 9075 
   - customerId
9076 
   - from_date
9077 
   - to_date
9078 
   - statuses
1149 chandransh 9079 
  """
9080 
 
9081 
  thrift_spec = (
9082 
    None, # 0
3064 chandransh 9083 
    (1, TType.I64, 'customerId', None, None, ), # 1
9084 
    (2, TType.I64, 'from_date', None, None, ), # 2
9085 
    (3, TType.I64, 'to_date', None, None, ), # 3
9086 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 9087 
  )
9088 
 
3064 chandransh 9089 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
9090 
    self.customerId = customerId
9091 
    self.from_date = from_date
9092 
    self.to_date = to_date
9093 
    self.statuses = statuses
1149 chandransh 9094 
 
9095 
  def read(self, iprot):
9096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9098 
      return
9099 
    iprot.readStructBegin()
9100 
    while True:
9101 
      (fname, ftype, fid) = iprot.readFieldBegin()
9102 
      if ftype == TType.STOP:
9103 
        break
9104 
      if fid == 1:
9105 
        if ftype == TType.I64:
3064 chandransh 9106 
          self.customerId = iprot.readI64();
1149 chandransh 9107 
        else:
9108 
          iprot.skip(ftype)
9109 
      elif fid == 2:
9110 
        if ftype == TType.I64:
3064 chandransh 9111 
          self.from_date = iprot.readI64();
1149 chandransh 9112 
        else:
9113 
          iprot.skip(ftype)
2783 chandransh 9114 
      elif fid == 3:
9115 
        if ftype == TType.I64:
3064 chandransh 9116 
          self.to_date = iprot.readI64();
2783 chandransh 9117 
        else:
9118 
          iprot.skip(ftype)
9119 
      elif fid == 4:
3064 chandransh 9120 
        if ftype == TType.LIST:
9121 
          self.statuses = []
5031 varun.gupt 9122 
          (_etype150, _size147) = iprot.readListBegin()
9123 
          for _i151 in xrange(_size147):
9124 
            _elem152 = iprot.readI32();
9125 
            self.statuses.append(_elem152)
3064 chandransh 9126 
          iprot.readListEnd()
2783 chandransh 9127 
        else:
9128 
          iprot.skip(ftype)
1149 chandransh 9129 
      else:
9130 
        iprot.skip(ftype)
9131 
      iprot.readFieldEnd()
9132 
    iprot.readStructEnd()
9133 
 
9134 
  def write(self, oprot):
9135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9137 
      return
3064 chandransh 9138 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 9139 
    if self.customerId is not None:
3064 chandransh 9140 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9141 
      oprot.writeI64(self.customerId)
1149 chandransh 9142 
      oprot.writeFieldEnd()
3431 rajveer 9143 
    if self.from_date is not None:
3064 chandransh 9144 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9145 
      oprot.writeI64(self.from_date)
1149 chandransh 9146 
      oprot.writeFieldEnd()
3431 rajveer 9147 
    if self.to_date is not None:
3064 chandransh 9148 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9149 
      oprot.writeI64(self.to_date)
2783 chandransh 9150 
      oprot.writeFieldEnd()
3431 rajveer 9151 
    if self.statuses is not None:
3064 chandransh 9152 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
9153 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 9154 
      for iter153 in self.statuses:
9155 
        oprot.writeI32(iter153)
3064 chandransh 9156 
      oprot.writeListEnd()
2783 chandransh 9157 
      oprot.writeFieldEnd()
1149 chandransh 9158 
    oprot.writeFieldStop()
9159 
    oprot.writeStructEnd()
9160 
 
3431 rajveer 9161 
  def validate(self):
9162 
    return
9163 
 
9164 
 
1149 chandransh 9165 
  def __repr__(self):
9166 
    L = ['%s=%r' % (key, value)
9167 
      for key, value in self.__dict__.iteritems()]
9168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9169 
 
9170 
  def __eq__(self, other):
9171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9172 
 
9173 
  def __ne__(self, other):
9174 
    return not (self == other)
9175 
 
3064 chandransh 9176 
class getOrdersForCustomer_result:
1149 chandransh 9177 
  """
9178 
  Attributes:
9179 
   - success
9180 
   - ex
9181 
  """
9182 
 
9183 
  thrift_spec = (
3064 chandransh 9184 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 9185 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9186 
  )
9187 
 
9188 
  def __init__(self, success=None, ex=None,):
9189 
    self.success = success
9190 
    self.ex = ex
9191 
 
9192 
  def read(self, iprot):
9193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9195 
      return
9196 
    iprot.readStructBegin()
9197 
    while True:
9198 
      (fname, ftype, fid) = iprot.readFieldBegin()
9199 
      if ftype == TType.STOP:
9200 
        break
9201 
      if fid == 0:
3064 chandransh 9202 
        if ftype == TType.LIST:
9203 
          self.success = []
5031 varun.gupt 9204 
          (_etype157, _size154) = iprot.readListBegin()
9205 
          for _i158 in xrange(_size154):
9206 
            _elem159 = Order()
9207 
            _elem159.read(iprot)
9208 
            self.success.append(_elem159)
3064 chandransh 9209 
          iprot.readListEnd()
1149 chandransh 9210 
        else:
9211 
          iprot.skip(ftype)
9212 
      elif fid == 1:
9213 
        if ftype == TType.STRUCT:
9214 
          self.ex = TransactionServiceException()
9215 
          self.ex.read(iprot)
9216 
        else:
9217 
          iprot.skip(ftype)
9218 
      else:
9219 
        iprot.skip(ftype)
9220 
      iprot.readFieldEnd()
9221 
    iprot.readStructEnd()
9222 
 
9223 
  def write(self, oprot):
9224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9226 
      return
3064 chandransh 9227 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 9228 
    if self.success is not None:
3064 chandransh 9229 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9230 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9231 
      for iter160 in self.success:
9232 
        iter160.write(oprot)
3064 chandransh 9233 
      oprot.writeListEnd()
1149 chandransh 9234 
      oprot.writeFieldEnd()
3431 rajveer 9235 
    if self.ex is not None:
1149 chandransh 9236 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9237 
      self.ex.write(oprot)
9238 
      oprot.writeFieldEnd()
9239 
    oprot.writeFieldStop()
9240 
    oprot.writeStructEnd()
9241 
 
3431 rajveer 9242 
  def validate(self):
9243 
    return
9244 
 
9245 
 
1149 chandransh 9246 
  def __repr__(self):
9247 
    L = ['%s=%r' % (key, value)
9248 
      for key, value in self.__dict__.iteritems()]
9249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9250 
 
9251 
  def __eq__(self, other):
9252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9253 
 
9254 
  def __ne__(self, other):
9255 
    return not (self == other)
9256 
 
3064 chandransh 9257 
class createOrder_args:
921 rajveer 9258 
  """
9259 
  Attributes:
3064 chandransh 9260 
   - order
921 rajveer 9261 
  """
9262 
 
9263 
  thrift_spec = (
9264 
    None, # 0
3064 chandransh 9265 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 9266 
  )
9267 
 
3064 chandransh 9268 
  def __init__(self, order=None,):
9269 
    self.order = order
921 rajveer 9270 
 
9271 
  def read(self, iprot):
9272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9274 
      return
9275 
    iprot.readStructBegin()
9276 
    while True:
9277 
      (fname, ftype, fid) = iprot.readFieldBegin()
9278 
      if ftype == TType.STOP:
9279 
        break
9280 
      if fid == 1:
3064 chandransh 9281 
        if ftype == TType.STRUCT:
9282 
          self.order = Order()
9283 
          self.order.read(iprot)
921 rajveer 9284 
        else:
9285 
          iprot.skip(ftype)
9286 
      else:
9287 
        iprot.skip(ftype)
9288 
      iprot.readFieldEnd()
9289 
    iprot.readStructEnd()
9290 
 
9291 
  def write(self, oprot):
9292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9294 
      return
3064 chandransh 9295 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 9296 
    if self.order is not None:
3064 chandransh 9297 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
9298 
      self.order.write(oprot)
921 rajveer 9299 
      oprot.writeFieldEnd()
9300 
    oprot.writeFieldStop()
9301 
    oprot.writeStructEnd()
9302 
 
3431 rajveer 9303 
  def validate(self):
9304 
    return
9305 
 
9306 
 
921 rajveer 9307 
  def __repr__(self):
9308 
    L = ['%s=%r' % (key, value)
9309 
      for key, value in self.__dict__.iteritems()]
9310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9311 
 
9312 
  def __eq__(self, other):
9313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9314 
 
9315 
  def __ne__(self, other):
9316 
    return not (self == other)
9317 
 
3064 chandransh 9318 
class createOrder_result:
921 rajveer 9319 
  """
9320 
  Attributes:
9321 
   - success
9322 
   - ex
9323 
  """
9324 
 
9325 
  thrift_spec = (
3064 chandransh 9326 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 9327 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9328 
  )
9329 
 
9330 
  def __init__(self, success=None, ex=None,):
9331 
    self.success = success
9332 
    self.ex = ex
9333 
 
9334 
  def read(self, iprot):
9335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9337 
      return
9338 
    iprot.readStructBegin()
9339 
    while True:
9340 
      (fname, ftype, fid) = iprot.readFieldBegin()
9341 
      if ftype == TType.STOP:
9342 
        break
9343 
      if fid == 0:
3064 chandransh 9344 
        if ftype == TType.I64:
9345 
          self.success = iprot.readI64();
921 rajveer 9346 
        else:
9347 
          iprot.skip(ftype)
9348 
      elif fid == 1:
9349 
        if ftype == TType.STRUCT:
9350 
          self.ex = TransactionServiceException()
9351 
          self.ex.read(iprot)
9352 
        else:
9353 
          iprot.skip(ftype)
9354 
      else:
9355 
        iprot.skip(ftype)
9356 
      iprot.readFieldEnd()
9357 
    iprot.readStructEnd()
9358 
 
9359 
  def write(self, oprot):
9360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9362 
      return
3064 chandransh 9363 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 9364 
    if self.success is not None:
3064 chandransh 9365 
      oprot.writeFieldBegin('success', TType.I64, 0)
9366 
      oprot.writeI64(self.success)
921 rajveer 9367 
      oprot.writeFieldEnd()
3431 rajveer 9368 
    if self.ex is not None:
921 rajveer 9369 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9370 
      self.ex.write(oprot)
9371 
      oprot.writeFieldEnd()
9372 
    oprot.writeFieldStop()
9373 
    oprot.writeStructEnd()
9374 
 
3431 rajveer 9375 
  def validate(self):
9376 
    return
9377 
 
9378 
 
921 rajveer 9379 
  def __repr__(self):
9380 
    L = ['%s=%r' % (key, value)
9381 
      for key, value in self.__dict__.iteritems()]
9382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9383 
 
9384 
  def __eq__(self, other):
9385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9386 
 
9387 
  def __ne__(self, other):
9388 
    return not (self == other)
9389 
 
3064 chandransh 9390 
class getOrder_args:
921 rajveer 9391 
  """
9392 
  Attributes:
3064 chandransh 9393 
   - id
921 rajveer 9394 
  """
9395 
 
9396 
  thrift_spec = (
9397 
    None, # 0
3064 chandransh 9398 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 9399 
  )
9400 
 
3064 chandransh 9401 
  def __init__(self, id=None,):
9402 
    self.id = id
921 rajveer 9403 
 
9404 
  def read(self, iprot):
9405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9407 
      return
9408 
    iprot.readStructBegin()
9409 
    while True:
9410 
      (fname, ftype, fid) = iprot.readFieldBegin()
9411 
      if ftype == TType.STOP:
9412 
        break
9413 
      if fid == 1:
9414 
        if ftype == TType.I64:
3064 chandransh 9415 
          self.id = iprot.readI64();
921 rajveer 9416 
        else:
9417 
          iprot.skip(ftype)
9418 
      else:
9419 
        iprot.skip(ftype)
9420 
      iprot.readFieldEnd()
9421 
    iprot.readStructEnd()
9422 
 
9423 
  def write(self, oprot):
9424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9426 
      return
3064 chandransh 9427 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 9428 
    if self.id is not None:
3064 chandransh 9429 
      oprot.writeFieldBegin('id', TType.I64, 1)
9430 
      oprot.writeI64(self.id)
921 rajveer 9431 
      oprot.writeFieldEnd()
9432 
    oprot.writeFieldStop()
9433 
    oprot.writeStructEnd()
9434 
 
3431 rajveer 9435 
  def validate(self):
9436 
    return
9437 
 
9438 
 
921 rajveer 9439 
  def __repr__(self):
9440 
    L = ['%s=%r' % (key, value)
9441 
      for key, value in self.__dict__.iteritems()]
9442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9443 
 
9444 
  def __eq__(self, other):
9445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9446 
 
9447 
  def __ne__(self, other):
9448 
    return not (self == other)
9449 
 
3064 chandransh 9450 
class getOrder_result:
921 rajveer 9451 
  """
9452 
  Attributes:
9453 
   - success
9454 
   - ex
9455 
  """
9456 
 
9457 
  thrift_spec = (
3064 chandransh 9458 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 9459 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9460 
  )
9461 
 
9462 
  def __init__(self, success=None, ex=None,):
9463 
    self.success = success
9464 
    self.ex = ex
9465 
 
9466 
  def read(self, iprot):
9467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9469 
      return
9470 
    iprot.readStructBegin()
9471 
    while True:
9472 
      (fname, ftype, fid) = iprot.readFieldBegin()
9473 
      if ftype == TType.STOP:
9474 
        break
9475 
      if fid == 0:
3064 chandransh 9476 
        if ftype == TType.STRUCT:
9477 
          self.success = Order()
9478 
          self.success.read(iprot)
921 rajveer 9479 
        else:
9480 
          iprot.skip(ftype)
9481 
      elif fid == 1:
9482 
        if ftype == TType.STRUCT:
9483 
          self.ex = TransactionServiceException()
9484 
          self.ex.read(iprot)
9485 
        else:
9486 
          iprot.skip(ftype)
9487 
      else:
9488 
        iprot.skip(ftype)
9489 
      iprot.readFieldEnd()
9490 
    iprot.readStructEnd()
9491 
 
9492 
  def write(self, oprot):
9493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9495 
      return
3064 chandransh 9496 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 9497 
    if self.success is not None:
3064 chandransh 9498 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9499 
      self.success.write(oprot)
921 rajveer 9500 
      oprot.writeFieldEnd()
3431 rajveer 9501 
    if self.ex is not None:
921 rajveer 9502 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9503 
      self.ex.write(oprot)
9504 
      oprot.writeFieldEnd()
9505 
    oprot.writeFieldStop()
9506 
    oprot.writeStructEnd()
9507 
 
3431 rajveer 9508 
  def validate(self):
9509 
    return
9510 
 
9511 
 
921 rajveer 9512 
  def __repr__(self):
9513 
    L = ['%s=%r' % (key, value)
9514 
      for key, value in self.__dict__.iteritems()]
9515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9516 
 
9517 
  def __eq__(self, other):
9518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9519 
 
9520 
  def __ne__(self, other):
9521 
    return not (self == other)
9522 
 
3064 chandransh 9523 
class getLineItemsForOrder_args:
94 ashish 9524 
  """
9525 
  Attributes:
3064 chandransh 9526 
   - orderId
94 ashish 9527 
  """
9528 
 
9529 
  thrift_spec = (
9530 
    None, # 0
3064 chandransh 9531 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 9532 
  )
9533 
 
3064 chandransh 9534 
  def __init__(self, orderId=None,):
9535 
    self.orderId = orderId
94 ashish 9536 
 
9537 
  def read(self, iprot):
9538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9540 
      return
9541 
    iprot.readStructBegin()
9542 
    while True:
9543 
      (fname, ftype, fid) = iprot.readFieldBegin()
9544 
      if ftype == TType.STOP:
9545 
        break
9546 
      if fid == 1:
9547 
        if ftype == TType.I64:
3064 chandransh 9548 
          self.orderId = iprot.readI64();
94 ashish 9549 
        else:
9550 
          iprot.skip(ftype)
9551 
      else:
9552 
        iprot.skip(ftype)
9553 
      iprot.readFieldEnd()
9554 
    iprot.readStructEnd()
9555 
 
9556 
  def write(self, oprot):
9557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9559 
      return
3064 chandransh 9560 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 9561 
    if self.orderId is not None:
3064 chandransh 9562 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9563 
      oprot.writeI64(self.orderId)
94 ashish 9564 
      oprot.writeFieldEnd()
9565 
    oprot.writeFieldStop()
9566 
    oprot.writeStructEnd()
9567 
 
3431 rajveer 9568 
  def validate(self):
9569 
    return
9570 
 
9571 
 
94 ashish 9572 
  def __repr__(self):
9573 
    L = ['%s=%r' % (key, value)
9574 
      for key, value in self.__dict__.iteritems()]
9575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9576 
 
9577 
  def __eq__(self, other):
9578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9579 
 
9580 
  def __ne__(self, other):
9581 
    return not (self == other)
9582 
 
3064 chandransh 9583 
class getLineItemsForOrder_result:
94 ashish 9584 
  """
9585 
  Attributes:
9586 
   - success
9587 
   - ex
9588 
  """
9589 
 
9590 
  thrift_spec = (
3064 chandransh 9591 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 9592 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9593 
  )
9594 
 
9595 
  def __init__(self, success=None, ex=None,):
9596 
    self.success = success
9597 
    self.ex = ex
9598 
 
9599 
  def read(self, iprot):
9600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9602 
      return
9603 
    iprot.readStructBegin()
9604 
    while True:
9605 
      (fname, ftype, fid) = iprot.readFieldBegin()
9606 
      if ftype == TType.STOP:
9607 
        break
9608 
      if fid == 0:
483 rajveer 9609 
        if ftype == TType.LIST:
9610 
          self.success = []
5031 varun.gupt 9611 
          (_etype164, _size161) = iprot.readListBegin()
9612 
          for _i165 in xrange(_size161):
9613 
            _elem166 = LineItem()
9614 
            _elem166.read(iprot)
9615 
            self.success.append(_elem166)
483 rajveer 9616 
          iprot.readListEnd()
94 ashish 9617 
        else:
9618 
          iprot.skip(ftype)
9619 
      elif fid == 1:
9620 
        if ftype == TType.STRUCT:
9621 
          self.ex = TransactionServiceException()
9622 
          self.ex.read(iprot)
9623 
        else:
9624 
          iprot.skip(ftype)
9625 
      else:
9626 
        iprot.skip(ftype)
9627 
      iprot.readFieldEnd()
9628 
    iprot.readStructEnd()
9629 
 
9630 
  def write(self, oprot):
9631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9633 
      return
3064 chandransh 9634 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 9635 
    if self.success is not None:
483 rajveer 9636 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9637 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9638 
      for iter167 in self.success:
9639 
        iter167.write(oprot)
483 rajveer 9640 
      oprot.writeListEnd()
94 ashish 9641 
      oprot.writeFieldEnd()
3431 rajveer 9642 
    if self.ex is not None:
94 ashish 9643 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9644 
      self.ex.write(oprot)
9645 
      oprot.writeFieldEnd()
9646 
    oprot.writeFieldStop()
9647 
    oprot.writeStructEnd()
9648 
 
3431 rajveer 9649 
  def validate(self):
9650 
    return
9651 
 
9652 
 
94 ashish 9653 
  def __repr__(self):
9654 
    L = ['%s=%r' % (key, value)
9655 
      for key, value in self.__dict__.iteritems()]
9656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9657 
 
9658 
  def __eq__(self, other):
9659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9660 
 
9661 
  def __ne__(self, other):
9662 
    return not (self == other)
9663 
 
4999 phani.kuma 9664 
class getOrderList_args:
9665 
  """
9666 
  Attributes:
9667 
   - order_ids
9668 
  """
9669 
 
9670 
  thrift_spec = (
9671 
    None, # 0
9672 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
9673 
  )
9674 
 
9675 
  def __init__(self, order_ids=None,):
9676 
    self.order_ids = order_ids
9677 
 
9678 
  def read(self, iprot):
9679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9681 
      return
9682 
    iprot.readStructBegin()
9683 
    while True:
9684 
      (fname, ftype, fid) = iprot.readFieldBegin()
9685 
      if ftype == TType.STOP:
9686 
        break
9687 
      if fid == 1:
9688 
        if ftype == TType.LIST:
9689 
          self.order_ids = []
5031 varun.gupt 9690 
          (_etype171, _size168) = iprot.readListBegin()
9691 
          for _i172 in xrange(_size168):
9692 
            _elem173 = iprot.readI64();
9693 
            self.order_ids.append(_elem173)
4999 phani.kuma 9694 
          iprot.readListEnd()
9695 
        else:
9696 
          iprot.skip(ftype)
9697 
      else:
9698 
        iprot.skip(ftype)
9699 
      iprot.readFieldEnd()
9700 
    iprot.readStructEnd()
9701 
 
9702 
  def write(self, oprot):
9703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9705 
      return
9706 
    oprot.writeStructBegin('getOrderList_args')
9707 
    if self.order_ids is not None:
9708 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
9709 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
5031 varun.gupt 9710 
      for iter174 in self.order_ids:
9711 
        oprot.writeI64(iter174)
4999 phani.kuma 9712 
      oprot.writeListEnd()
9713 
      oprot.writeFieldEnd()
9714 
    oprot.writeFieldStop()
9715 
    oprot.writeStructEnd()
9716 
 
9717 
  def validate(self):
9718 
    return
9719 
 
9720 
 
9721 
  def __repr__(self):
9722 
    L = ['%s=%r' % (key, value)
9723 
      for key, value in self.__dict__.iteritems()]
9724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9725 
 
9726 
  def __eq__(self, other):
9727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9728 
 
9729 
  def __ne__(self, other):
9730 
    return not (self == other)
9731 
 
9732 
class getOrderList_result:
9733 
  """
9734 
  Attributes:
9735 
   - success
9736 
  """
9737 
 
9738 
  thrift_spec = (
9739 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9740 
  )
9741 
 
9742 
  def __init__(self, success=None,):
9743 
    self.success = success
9744 
 
9745 
  def read(self, iprot):
9746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9748 
      return
9749 
    iprot.readStructBegin()
9750 
    while True:
9751 
      (fname, ftype, fid) = iprot.readFieldBegin()
9752 
      if ftype == TType.STOP:
9753 
        break
9754 
      if fid == 0:
9755 
        if ftype == TType.LIST:
9756 
          self.success = []
5031 varun.gupt 9757 
          (_etype178, _size175) = iprot.readListBegin()
9758 
          for _i179 in xrange(_size175):
9759 
            _elem180 = Order()
9760 
            _elem180.read(iprot)
9761 
            self.success.append(_elem180)
4999 phani.kuma 9762 
          iprot.readListEnd()
9763 
        else:
9764 
          iprot.skip(ftype)
9765 
      else:
9766 
        iprot.skip(ftype)
9767 
      iprot.readFieldEnd()
9768 
    iprot.readStructEnd()
9769 
 
9770 
  def write(self, oprot):
9771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9773 
      return
9774 
    oprot.writeStructBegin('getOrderList_result')
9775 
    if self.success is not None:
9776 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9777 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9778 
      for iter181 in self.success:
9779 
        iter181.write(oprot)
4999 phani.kuma 9780 
      oprot.writeListEnd()
9781 
      oprot.writeFieldEnd()
9782 
    oprot.writeFieldStop()
9783 
    oprot.writeStructEnd()
9784 
 
9785 
  def validate(self):
9786 
    return
9787 
 
9788 
 
9789 
  def __repr__(self):
9790 
    L = ['%s=%r' % (key, value)
9791 
      for key, value in self.__dict__.iteritems()]
9792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9793 
 
9794 
  def __eq__(self, other):
9795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9796 
 
9797 
  def __ne__(self, other):
9798 
    return not (self == other)
9799 
 
3064 chandransh 9800 
class getOrderForCustomer_args:
94 ashish 9801 
  """
9802 
  Attributes:
3064 chandransh 9803 
   - orderId
483 rajveer 9804 
   - customerId
94 ashish 9805 
  """
9806 
 
9807 
  thrift_spec = (
9808 
    None, # 0
3064 chandransh 9809 
    (1, TType.I64, 'orderId', None, None, ), # 1
9810 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 9811 
  )
9812 
 
3064 chandransh 9813 
  def __init__(self, orderId=None, customerId=None,):
9814 
    self.orderId = orderId
483 rajveer 9815 
    self.customerId = customerId
94 ashish 9816 
 
9817 
  def read(self, iprot):
9818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9820 
      return
9821 
    iprot.readStructBegin()
9822 
    while True:
9823 
      (fname, ftype, fid) = iprot.readFieldBegin()
9824 
      if ftype == TType.STOP:
9825 
        break
9826 
      if fid == 1:
9827 
        if ftype == TType.I64:
3064 chandransh 9828 
          self.orderId = iprot.readI64();
94 ashish 9829 
        else:
9830 
          iprot.skip(ftype)
9831 
      elif fid == 2:
9832 
        if ftype == TType.I64:
3064 chandransh 9833 
          self.customerId = iprot.readI64();
94 ashish 9834 
        else:
9835 
          iprot.skip(ftype)
9836 
      else:
9837 
        iprot.skip(ftype)
9838 
      iprot.readFieldEnd()
9839 
    iprot.readStructEnd()
9840 
 
9841 
  def write(self, oprot):
9842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9844 
      return
3064 chandransh 9845 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 9846 
    if self.orderId is not None:
3064 chandransh 9847 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9848 
      oprot.writeI64(self.orderId)
9849 
      oprot.writeFieldEnd()
3431 rajveer 9850 
    if self.customerId is not None:
3064 chandransh 9851 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 9852 
      oprot.writeI64(self.customerId)
94 ashish 9853 
      oprot.writeFieldEnd()
9854 
    oprot.writeFieldStop()
9855 
    oprot.writeStructEnd()
9856 
 
3431 rajveer 9857 
  def validate(self):
9858 
    return
9859 
 
9860 
 
94 ashish 9861 
  def __repr__(self):
9862 
    L = ['%s=%r' % (key, value)
9863 
      for key, value in self.__dict__.iteritems()]
9864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9865 
 
9866 
  def __eq__(self, other):
9867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9868 
 
9869 
  def __ne__(self, other):
9870 
    return not (self == other)
9871 
 
3064 chandransh 9872 
class getOrderForCustomer_result:
94 ashish 9873 
  """
9874 
  Attributes:
9875 
   - success
9876 
   - ex
9877 
  """
9878 
 
9879 
  thrift_spec = (
3064 chandransh 9880 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 9881 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9882 
  )
9883 
 
9884 
  def __init__(self, success=None, ex=None,):
9885 
    self.success = success
9886 
    self.ex = ex
9887 
 
9888 
  def read(self, iprot):
9889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9891 
      return
9892 
    iprot.readStructBegin()
9893 
    while True:
9894 
      (fname, ftype, fid) = iprot.readFieldBegin()
9895 
      if ftype == TType.STOP:
9896 
        break
9897 
      if fid == 0:
3064 chandransh 9898 
        if ftype == TType.STRUCT:
9899 
          self.success = Order()
9900 
          self.success.read(iprot)
94 ashish 9901 
        else:
9902 
          iprot.skip(ftype)
9903 
      elif fid == 1:
9904 
        if ftype == TType.STRUCT:
9905 
          self.ex = TransactionServiceException()
9906 
          self.ex.read(iprot)
9907 
        else:
9908 
          iprot.skip(ftype)
9909 
      else:
9910 
        iprot.skip(ftype)
9911 
      iprot.readFieldEnd()
9912 
    iprot.readStructEnd()
9913 
 
9914 
  def write(self, oprot):
9915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9917 
      return
3064 chandransh 9918 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 9919 
    if self.success is not None:
3064 chandransh 9920 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9921 
      self.success.write(oprot)
94 ashish 9922 
      oprot.writeFieldEnd()
3431 rajveer 9923 
    if self.ex is not None:
94 ashish 9924 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9925 
      self.ex.write(oprot)
9926 
      oprot.writeFieldEnd()
9927 
    oprot.writeFieldStop()
9928 
    oprot.writeStructEnd()
9929 
 
3431 rajveer 9930 
  def validate(self):
9931 
    return
9932 
 
9933 
 
94 ashish 9934 
  def __repr__(self):
9935 
    L = ['%s=%r' % (key, value)
9936 
      for key, value in self.__dict__.iteritems()]
9937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9938 
 
9939 
  def __eq__(self, other):
9940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9941 
 
9942 
  def __ne__(self, other):
9943 
    return not (self == other)
9944 
 
3064 chandransh 9945 
class getAlerts_args:
94 ashish 9946 
  """
9947 
  Attributes:
4394 rajveer 9948 
   - type
4444 rajveer 9949 
   - warehouseId
4394 rajveer 9950 
   - status
9951 
   - timestamp
94 ashish 9952 
  """
9953 
 
9954 
  thrift_spec = (
9955 
    None, # 0
4394 rajveer 9956 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 9957 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9958 
    (3, TType.I64, 'status', None, None, ), # 3
9959 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 9960 
  )
9961 
 
4444 rajveer 9962 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 9963 
    self.type = type
4444 rajveer 9964 
    self.warehouseId = warehouseId
4394 rajveer 9965 
    self.status = status
9966 
    self.timestamp = timestamp
94 ashish 9967 
 
9968 
  def read(self, iprot):
9969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9971 
      return
9972 
    iprot.readStructBegin()
9973 
    while True:
9974 
      (fname, ftype, fid) = iprot.readFieldBegin()
9975 
      if ftype == TType.STOP:
9976 
        break
9977 
      if fid == 1:
3064 chandransh 9978 
        if ftype == TType.I64:
4394 rajveer 9979 
          self.type = iprot.readI64();
94 ashish 9980 
        else:
9981 
          iprot.skip(ftype)
3064 chandransh 9982 
      elif fid == 2:
4394 rajveer 9983 
        if ftype == TType.I64:
4444 rajveer 9984 
          self.warehouseId = iprot.readI64();
3064 chandransh 9985 
        else:
9986 
          iprot.skip(ftype)
4394 rajveer 9987 
      elif fid == 3:
9988 
        if ftype == TType.I64:
4444 rajveer 9989 
          self.status = iprot.readI64();
9990 
        else:
9991 
          iprot.skip(ftype)
9992 
      elif fid == 4:
9993 
        if ftype == TType.I64:
4394 rajveer 9994 
          self.timestamp = iprot.readI64();
9995 
        else:
9996 
          iprot.skip(ftype)
94 ashish 9997 
      else:
9998 
        iprot.skip(ftype)
9999 
      iprot.readFieldEnd()
10000 
    iprot.readStructEnd()
10001 
 
10002 
  def write(self, oprot):
10003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10005 
      return
3064 chandransh 10006 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 10007 
    if self.type is not None:
10008 
      oprot.writeFieldBegin('type', TType.I64, 1)
10009 
      oprot.writeI64(self.type)
94 ashish 10010 
      oprot.writeFieldEnd()
4444 rajveer 10011 
    if self.warehouseId is not None:
10012 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10013 
      oprot.writeI64(self.warehouseId)
10014 
      oprot.writeFieldEnd()
4394 rajveer 10015 
    if self.status is not None:
4444 rajveer 10016 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 10017 
      oprot.writeI64(self.status)
3064 chandransh 10018 
      oprot.writeFieldEnd()
4394 rajveer 10019 
    if self.timestamp is not None:
4444 rajveer 10020 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 10021 
      oprot.writeI64(self.timestamp)
10022 
      oprot.writeFieldEnd()
94 ashish 10023 
    oprot.writeFieldStop()
10024 
    oprot.writeStructEnd()
10025 
 
3431 rajveer 10026 
  def validate(self):
10027 
    return
10028 
 
10029 
 
94 ashish 10030 
  def __repr__(self):
10031 
    L = ['%s=%r' % (key, value)
10032 
      for key, value in self.__dict__.iteritems()]
10033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10034 
 
10035 
  def __eq__(self, other):
10036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10037 
 
10038 
  def __ne__(self, other):
10039 
    return not (self == other)
10040 
 
3064 chandransh 10041 
class getAlerts_result:
94 ashish 10042 
  """
10043 
  Attributes:
10044 
   - success
10045 
  """
10046 
 
10047 
  thrift_spec = (
3064 chandransh 10048 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 10049 
  )
10050 
 
3064 chandransh 10051 
  def __init__(self, success=None,):
94 ashish 10052 
    self.success = success
10053 
 
10054 
  def read(self, iprot):
10055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10057 
      return
10058 
    iprot.readStructBegin()
10059 
    while True:
10060 
      (fname, ftype, fid) = iprot.readFieldBegin()
10061 
      if ftype == TType.STOP:
10062 
        break
10063 
      if fid == 0:
3064 chandransh 10064 
        if ftype == TType.LIST:
10065 
          self.success = []
5031 varun.gupt 10066 
          (_etype185, _size182) = iprot.readListBegin()
10067 
          for _i186 in xrange(_size182):
10068 
            _elem187 = Alert()
10069 
            _elem187.read(iprot)
10070 
            self.success.append(_elem187)
3064 chandransh 10071 
          iprot.readListEnd()
94 ashish 10072 
        else:
10073 
          iprot.skip(ftype)
10074 
      else:
10075 
        iprot.skip(ftype)
10076 
      iprot.readFieldEnd()
10077 
    iprot.readStructEnd()
10078 
 
10079 
  def write(self, oprot):
10080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10082 
      return
3064 chandransh 10083 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 10084 
    if self.success is not None:
3064 chandransh 10085 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10086 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10087 
      for iter188 in self.success:
10088 
        iter188.write(oprot)
3064 chandransh 10089 
      oprot.writeListEnd()
94 ashish 10090 
      oprot.writeFieldEnd()
10091 
    oprot.writeFieldStop()
10092 
    oprot.writeStructEnd()
10093 
 
3431 rajveer 10094 
  def validate(self):
10095 
    return
10096 
 
10097 
 
94 ashish 10098 
  def __repr__(self):
10099 
    L = ['%s=%r' % (key, value)
10100 
      for key, value in self.__dict__.iteritems()]
10101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10102 
 
10103 
  def __eq__(self, other):
10104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10105 
 
10106 
  def __ne__(self, other):
10107 
    return not (self == other)
10108 
 
4394 rajveer 10109 
class addAlert_args:
94 ashish 10110 
  """
10111 
  Attributes:
3064 chandransh 10112 
   - type
4444 rajveer 10113 
   - warehouseId
4394 rajveer 10114 
   - description
94 ashish 10115 
  """
10116 
 
10117 
  thrift_spec = (
10118 
    None, # 0
4394 rajveer 10119 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10120 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10121 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10122 
  )
10123 
 
4444 rajveer 10124 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 10125 
    self.type = type
4444 rajveer 10126 
    self.warehouseId = warehouseId
4394 rajveer 10127 
    self.description = description
94 ashish 10128 
 
10129 
  def read(self, iprot):
10130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10132 
      return
10133 
    iprot.readStructBegin()
10134 
    while True:
10135 
      (fname, ftype, fid) = iprot.readFieldBegin()
10136 
      if ftype == TType.STOP:
10137 
        break
10138 
      if fid == 1:
10139 
        if ftype == TType.I64:
4394 rajveer 10140 
          self.type = iprot.readI64();
94 ashish 10141 
        else:
10142 
          iprot.skip(ftype)
3064 chandransh 10143 
      elif fid == 2:
4444 rajveer 10144 
        if ftype == TType.I64:
10145 
          self.warehouseId = iprot.readI64();
10146 
        else:
10147 
          iprot.skip(ftype)
10148 
      elif fid == 3:
3064 chandransh 10149 
        if ftype == TType.STRING:
4394 rajveer 10150 
          self.description = iprot.readString();
3064 chandransh 10151 
        else:
10152 
          iprot.skip(ftype)
94 ashish 10153 
      else:
10154 
        iprot.skip(ftype)
10155 
      iprot.readFieldEnd()
10156 
    iprot.readStructEnd()
10157 
 
10158 
  def write(self, oprot):
10159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10161 
      return
4394 rajveer 10162 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 10163 
    if self.type is not None:
4394 rajveer 10164 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 10165 
      oprot.writeI64(self.type)
10166 
      oprot.writeFieldEnd()
4444 rajveer 10167 
    if self.warehouseId is not None:
10168 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10169 
      oprot.writeI64(self.warehouseId)
10170 
      oprot.writeFieldEnd()
4394 rajveer 10171 
    if self.description is not None:
4444 rajveer 10172 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 10173 
      oprot.writeString(self.description)
3064 chandransh 10174 
      oprot.writeFieldEnd()
94 ashish 10175 
    oprot.writeFieldStop()
10176 
    oprot.writeStructEnd()
10177 
 
3431 rajveer 10178 
  def validate(self):
10179 
    return
10180 
 
10181 
 
94 ashish 10182 
  def __repr__(self):
10183 
    L = ['%s=%r' % (key, value)
10184 
      for key, value in self.__dict__.iteritems()]
10185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10186 
 
10187 
  def __eq__(self, other):
10188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10189 
 
10190 
  def __ne__(self, other):
10191 
    return not (self == other)
10192 
 
4394 rajveer 10193 
class addAlert_result:
3064 chandransh 10194 
 
10195 
  thrift_spec = (
10196 
  )
10197 
 
10198 
  def read(self, iprot):
10199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10201 
      return
10202 
    iprot.readStructBegin()
10203 
    while True:
10204 
      (fname, ftype, fid) = iprot.readFieldBegin()
10205 
      if ftype == TType.STOP:
10206 
        break
10207 
      else:
10208 
        iprot.skip(ftype)
10209 
      iprot.readFieldEnd()
10210 
    iprot.readStructEnd()
10211 
 
10212 
  def write(self, oprot):
10213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10215 
      return
4394 rajveer 10216 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 10217 
    oprot.writeFieldStop()
10218 
    oprot.writeStructEnd()
10219 
 
3431 rajveer 10220 
  def validate(self):
10221 
    return
10222 
 
10223 
 
3064 chandransh 10224 
  def __repr__(self):
10225 
    L = ['%s=%r' % (key, value)
10226 
      for key, value in self.__dict__.iteritems()]
10227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10228 
 
10229 
  def __eq__(self, other):
10230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10231 
 
10232 
  def __ne__(self, other):
10233 
    return not (self == other)
10234 
 
4444 rajveer 10235 
class markAlertsAsSeen_args:
10236 
  """
10237 
  Attributes:
10238 
   - warehouseId
10239 
  """
10240 
 
10241 
  thrift_spec = (
10242 
    None, # 0
10243 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10244 
  )
10245 
 
10246 
  def __init__(self, warehouseId=None,):
10247 
    self.warehouseId = warehouseId
10248 
 
10249 
  def read(self, iprot):
10250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10252 
      return
10253 
    iprot.readStructBegin()
10254 
    while True:
10255 
      (fname, ftype, fid) = iprot.readFieldBegin()
10256 
      if ftype == TType.STOP:
10257 
        break
10258 
      if fid == 1:
10259 
        if ftype == TType.I64:
10260 
          self.warehouseId = iprot.readI64();
10261 
        else:
10262 
          iprot.skip(ftype)
10263 
      else:
10264 
        iprot.skip(ftype)
10265 
      iprot.readFieldEnd()
10266 
    iprot.readStructEnd()
10267 
 
10268 
  def write(self, oprot):
10269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10271 
      return
10272 
    oprot.writeStructBegin('markAlertsAsSeen_args')
10273 
    if self.warehouseId is not None:
10274 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10275 
      oprot.writeI64(self.warehouseId)
10276 
      oprot.writeFieldEnd()
10277 
    oprot.writeFieldStop()
10278 
    oprot.writeStructEnd()
10279 
 
10280 
  def validate(self):
10281 
    return
10282 
 
10283 
 
10284 
  def __repr__(self):
10285 
    L = ['%s=%r' % (key, value)
10286 
      for key, value in self.__dict__.iteritems()]
10287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10288 
 
10289 
  def __eq__(self, other):
10290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10291 
 
10292 
  def __ne__(self, other):
10293 
    return not (self == other)
10294 
 
10295 
class markAlertsAsSeen_result:
10296 
 
10297 
  thrift_spec = (
10298 
  )
10299 
 
10300 
  def read(self, iprot):
10301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10303 
      return
10304 
    iprot.readStructBegin()
10305 
    while True:
10306 
      (fname, ftype, fid) = iprot.readFieldBegin()
10307 
      if ftype == TType.STOP:
10308 
        break
10309 
      else:
10310 
        iprot.skip(ftype)
10311 
      iprot.readFieldEnd()
10312 
    iprot.readStructEnd()
10313 
 
10314 
  def write(self, oprot):
10315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10317 
      return
10318 
    oprot.writeStructBegin('markAlertsAsSeen_result')
10319 
    oprot.writeFieldStop()
10320 
    oprot.writeStructEnd()
10321 
 
10322 
  def validate(self):
10323 
    return
10324 
 
10325 
 
10326 
  def __repr__(self):
10327 
    L = ['%s=%r' % (key, value)
10328 
      for key, value in self.__dict__.iteritems()]
10329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10330 
 
10331 
  def __eq__(self, other):
10332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10333 
 
10334 
  def __ne__(self, other):
10335 
    return not (self == other)
10336 
 
3064 chandransh 10337 
class getValidOrderCount_args:
10338 
 
10339 
  thrift_spec = (
10340 
  )
10341 
 
10342 
  def read(self, iprot):
10343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10345 
      return
10346 
    iprot.readStructBegin()
10347 
    while True:
10348 
      (fname, ftype, fid) = iprot.readFieldBegin()
10349 
      if ftype == TType.STOP:
10350 
        break
10351 
      else:
10352 
        iprot.skip(ftype)
10353 
      iprot.readFieldEnd()
10354 
    iprot.readStructEnd()
10355 
 
10356 
  def write(self, oprot):
10357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10359 
      return
10360 
    oprot.writeStructBegin('getValidOrderCount_args')
10361 
    oprot.writeFieldStop()
10362 
    oprot.writeStructEnd()
10363 
 
3431 rajveer 10364 
  def validate(self):
10365 
    return
10366 
 
10367 
 
3064 chandransh 10368 
  def __repr__(self):
10369 
    L = ['%s=%r' % (key, value)
10370 
      for key, value in self.__dict__.iteritems()]
10371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10372 
 
10373 
  def __eq__(self, other):
10374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10375 
 
10376 
  def __ne__(self, other):
10377 
    return not (self == other)
10378 
 
10379 
class getValidOrderCount_result:
94 ashish 10380 
  """
10381 
  Attributes:
10382 
   - success
10383 
  """
10384 
 
10385 
  thrift_spec = (
3064 chandransh 10386 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10387 
  )
10388 
 
3064 chandransh 10389 
  def __init__(self, success=None,):
94 ashish 10390 
    self.success = success
10391 
 
10392 
  def read(self, iprot):
10393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10395 
      return
10396 
    iprot.readStructBegin()
10397 
    while True:
10398 
      (fname, ftype, fid) = iprot.readFieldBegin()
10399 
      if ftype == TType.STOP:
10400 
        break
10401 
      if fid == 0:
3064 chandransh 10402 
        if ftype == TType.I64:
10403 
          self.success = iprot.readI64();
94 ashish 10404 
        else:
10405 
          iprot.skip(ftype)
10406 
      else:
10407 
        iprot.skip(ftype)
10408 
      iprot.readFieldEnd()
10409 
    iprot.readStructEnd()
10410 
 
10411 
  def write(self, oprot):
10412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10414 
      return
3064 chandransh 10415 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 10416 
    if self.success is not None:
3064 chandransh 10417 
      oprot.writeFieldBegin('success', TType.I64, 0)
10418 
      oprot.writeI64(self.success)
94 ashish 10419 
      oprot.writeFieldEnd()
10420 
    oprot.writeFieldStop()
10421 
    oprot.writeStructEnd()
10422 
 
3431 rajveer 10423 
  def validate(self):
10424 
    return
10425 
 
10426 
 
94 ashish 10427 
  def __repr__(self):
10428 
    L = ['%s=%r' % (key, value)
10429 
      for key, value in self.__dict__.iteritems()]
10430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10431 
 
10432 
  def __eq__(self, other):
10433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10434 
 
10435 
  def __ne__(self, other):
10436 
    return not (self == other)
10437 
 
3064 chandransh 10438 
class getNoOfCustomersWithSuccessfulTransaction_args:
10439 
 
10440 
  thrift_spec = (
10441 
  )
10442 
 
10443 
  def read(self, iprot):
10444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10446 
      return
10447 
    iprot.readStructBegin()
10448 
    while True:
10449 
      (fname, ftype, fid) = iprot.readFieldBegin()
10450 
      if ftype == TType.STOP:
10451 
        break
10452 
      else:
10453 
        iprot.skip(ftype)
10454 
      iprot.readFieldEnd()
10455 
    iprot.readStructEnd()
10456 
 
10457 
  def write(self, oprot):
10458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10460 
      return
10461 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
10462 
    oprot.writeFieldStop()
10463 
    oprot.writeStructEnd()
10464 
 
3431 rajveer 10465 
  def validate(self):
10466 
    return
10467 
 
10468 
 
3064 chandransh 10469 
  def __repr__(self):
10470 
    L = ['%s=%r' % (key, value)
10471 
      for key, value in self.__dict__.iteritems()]
10472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10473 
 
10474 
  def __eq__(self, other):
10475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10476 
 
10477 
  def __ne__(self, other):
10478 
    return not (self == other)
10479 
 
10480 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 10481 
  """
10482 
  Attributes:
3064 chandransh 10483 
   - success
94 ashish 10484 
  """
10485 
 
10486 
  thrift_spec = (
3064 chandransh 10487 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10488 
  )
10489 
 
3064 chandransh 10490 
  def __init__(self, success=None,):
10491 
    self.success = success
94 ashish 10492 
 
10493 
  def read(self, iprot):
10494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10496 
      return
10497 
    iprot.readStructBegin()
10498 
    while True:
10499 
      (fname, ftype, fid) = iprot.readFieldBegin()
10500 
      if ftype == TType.STOP:
10501 
        break
3064 chandransh 10502 
      if fid == 0:
94 ashish 10503 
        if ftype == TType.I64:
3064 chandransh 10504 
          self.success = iprot.readI64();
94 ashish 10505 
        else:
10506 
          iprot.skip(ftype)
10507 
      else:
10508 
        iprot.skip(ftype)
10509 
      iprot.readFieldEnd()
10510 
    iprot.readStructEnd()
10511 
 
10512 
  def write(self, oprot):
10513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10515 
      return
3064 chandransh 10516 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 10517 
    if self.success is not None:
3064 chandransh 10518 
      oprot.writeFieldBegin('success', TType.I64, 0)
10519 
      oprot.writeI64(self.success)
94 ashish 10520 
      oprot.writeFieldEnd()
10521 
    oprot.writeFieldStop()
10522 
    oprot.writeStructEnd()
10523 
 
3431 rajveer 10524 
  def validate(self):
10525 
    return
10526 
 
10527 
 
94 ashish 10528 
  def __repr__(self):
10529 
    L = ['%s=%r' % (key, value)
10530 
      for key, value in self.__dict__.iteritems()]
10531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10532 
 
10533 
  def __eq__(self, other):
10534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10535 
 
10536 
  def __ne__(self, other):
10537 
    return not (self == other)
10538 
 
3064 chandransh 10539 
class getValidOrdersAmountRange_args:
10540 
 
10541 
  thrift_spec = (
10542 
  )
10543 
 
10544 
  def read(self, iprot):
10545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10547 
      return
10548 
    iprot.readStructBegin()
10549 
    while True:
10550 
      (fname, ftype, fid) = iprot.readFieldBegin()
10551 
      if ftype == TType.STOP:
10552 
        break
10553 
      else:
10554 
        iprot.skip(ftype)
10555 
      iprot.readFieldEnd()
10556 
    iprot.readStructEnd()
10557 
 
10558 
  def write(self, oprot):
10559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10561 
      return
10562 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
10563 
    oprot.writeFieldStop()
10564 
    oprot.writeStructEnd()
10565 
 
3431 rajveer 10566 
  def validate(self):
10567 
    return
10568 
 
10569 
 
3064 chandransh 10570 
  def __repr__(self):
10571 
    L = ['%s=%r' % (key, value)
10572 
      for key, value in self.__dict__.iteritems()]
10573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10574 
 
10575 
  def __eq__(self, other):
10576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10577 
 
10578 
  def __ne__(self, other):
10579 
    return not (self == other)
10580 
 
10581 
class getValidOrdersAmountRange_result:
94 ashish 10582 
  """
10583 
  Attributes:
10584 
   - success
10585 
  """
10586 
 
10587 
  thrift_spec = (
3064 chandransh 10588 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 10589 
  )
10590 
 
3064 chandransh 10591 
  def __init__(self, success=None,):
94 ashish 10592 
    self.success = success
10593 
 
10594 
  def read(self, iprot):
10595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10597 
      return
10598 
    iprot.readStructBegin()
10599 
    while True:
10600 
      (fname, ftype, fid) = iprot.readFieldBegin()
10601 
      if ftype == TType.STOP:
10602 
        break
10603 
      if fid == 0:
483 rajveer 10604 
        if ftype == TType.LIST:
10605 
          self.success = []
5031 varun.gupt 10606 
          (_etype192, _size189) = iprot.readListBegin()
10607 
          for _i193 in xrange(_size189):
10608 
            _elem194 = iprot.readDouble();
10609 
            self.success.append(_elem194)
483 rajveer 10610 
          iprot.readListEnd()
94 ashish 10611 
        else:
10612 
          iprot.skip(ftype)
10613 
      else:
10614 
        iprot.skip(ftype)
10615 
      iprot.readFieldEnd()
10616 
    iprot.readStructEnd()
10617 
 
10618 
  def write(self, oprot):
10619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10621 
      return
3064 chandransh 10622 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 10623 
    if self.success is not None:
483 rajveer 10624 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 10625 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
5031 varun.gupt 10626 
      for iter195 in self.success:
10627 
        oprot.writeDouble(iter195)
483 rajveer 10628 
      oprot.writeListEnd()
94 ashish 10629 
      oprot.writeFieldEnd()
10630 
    oprot.writeFieldStop()
10631 
    oprot.writeStructEnd()
10632 
 
3431 rajveer 10633 
  def validate(self):
10634 
    return
10635 
 
10636 
 
94 ashish 10637 
  def __repr__(self):
10638 
    L = ['%s=%r' % (key, value)
10639 
      for key, value in self.__dict__.iteritems()]
10640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10641 
 
10642 
  def __eq__(self, other):
10643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10644 
 
10645 
  def __ne__(self, other):
10646 
    return not (self == other)
10647 
 
3064 chandransh 10648 
class getValidOrders_args:
1528 ankur.sing 10649 
  """
10650 
  Attributes:
3064 chandransh 10651 
   - limit
1528 ankur.sing 10652 
  """
10653 
 
10654 
  thrift_spec = (
10655 
    None, # 0
3064 chandransh 10656 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 10657 
  )
10658 
 
3064 chandransh 10659 
  def __init__(self, limit=None,):
10660 
    self.limit = limit
1528 ankur.sing 10661 
 
10662 
  def read(self, iprot):
10663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10665 
      return
10666 
    iprot.readStructBegin()
10667 
    while True:
10668 
      (fname, ftype, fid) = iprot.readFieldBegin()
10669 
      if ftype == TType.STOP:
10670 
        break
10671 
      if fid == 1:
10672 
        if ftype == TType.I64:
3064 chandransh 10673 
          self.limit = iprot.readI64();
1528 ankur.sing 10674 
        else:
10675 
          iprot.skip(ftype)
10676 
      else:
10677 
        iprot.skip(ftype)
10678 
      iprot.readFieldEnd()
10679 
    iprot.readStructEnd()
10680 
 
10681 
  def write(self, oprot):
10682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10684 
      return
3064 chandransh 10685 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 10686 
    if self.limit is not None:
3064 chandransh 10687 
      oprot.writeFieldBegin('limit', TType.I64, 1)
10688 
      oprot.writeI64(self.limit)
1528 ankur.sing 10689 
      oprot.writeFieldEnd()
10690 
    oprot.writeFieldStop()
10691 
    oprot.writeStructEnd()
10692 
 
3431 rajveer 10693 
  def validate(self):
10694 
    return
10695 
 
10696 
 
1528 ankur.sing 10697 
  def __repr__(self):
10698 
    L = ['%s=%r' % (key, value)
10699 
      for key, value in self.__dict__.iteritems()]
10700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10701 
 
10702 
  def __eq__(self, other):
10703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10704 
 
10705 
  def __ne__(self, other):
10706 
    return not (self == other)
10707 
 
3064 chandransh 10708 
class getValidOrders_result:
1528 ankur.sing 10709 
  """
10710 
  Attributes:
10711 
   - success
10712 
  """
10713 
 
10714 
  thrift_spec = (
3064 chandransh 10715 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 10716 
  )
10717 
 
3064 chandransh 10718 
  def __init__(self, success=None,):
1528 ankur.sing 10719 
    self.success = success
10720 
 
10721 
  def read(self, iprot):
10722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10724 
      return
10725 
    iprot.readStructBegin()
10726 
    while True:
10727 
      (fname, ftype, fid) = iprot.readFieldBegin()
10728 
      if ftype == TType.STOP:
10729 
        break
10730 
      if fid == 0:
3064 chandransh 10731 
        if ftype == TType.LIST:
10732 
          self.success = []
5031 varun.gupt 10733 
          (_etype199, _size196) = iprot.readListBegin()
10734 
          for _i200 in xrange(_size196):
10735 
            _elem201 = Order()
10736 
            _elem201.read(iprot)
10737 
            self.success.append(_elem201)
3064 chandransh 10738 
          iprot.readListEnd()
1528 ankur.sing 10739 
        else:
10740 
          iprot.skip(ftype)
10741 
      else:
10742 
        iprot.skip(ftype)
10743 
      iprot.readFieldEnd()
10744 
    iprot.readStructEnd()
10745 
 
10746 
  def write(self, oprot):
10747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10749 
      return
3064 chandransh 10750 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 10751 
    if self.success is not None:
3064 chandransh 10752 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10753 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10754 
      for iter202 in self.success:
10755 
        iter202.write(oprot)
3064 chandransh 10756 
      oprot.writeListEnd()
1528 ankur.sing 10757 
      oprot.writeFieldEnd()
10758 
    oprot.writeFieldStop()
10759 
    oprot.writeStructEnd()
10760 
 
3431 rajveer 10761 
  def validate(self):
10762 
    return
10763 
 
10764 
 
1528 ankur.sing 10765 
  def __repr__(self):
10766 
    L = ['%s=%r' % (key, value)
10767 
      for key, value in self.__dict__.iteritems()]
10768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10769 
 
10770 
  def __eq__(self, other):
10771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10772 
 
10773 
  def __ne__(self, other):
10774 
    return not (self == other)
10775 
 
1220 chandransh 10776 
class batchOrders_args:
10777 
  """
10778 
  Attributes:
10779 
   - warehouseId
10780 
  """
10781 
 
10782 
  thrift_spec = (
10783 
    None, # 0
10784 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10785 
  )
10786 
 
10787 
  def __init__(self, warehouseId=None,):
10788 
    self.warehouseId = warehouseId
10789 
 
10790 
  def read(self, iprot):
10791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10793 
      return
10794 
    iprot.readStructBegin()
10795 
    while True:
10796 
      (fname, ftype, fid) = iprot.readFieldBegin()
10797 
      if ftype == TType.STOP:
10798 
        break
10799 
      if fid == 1:
10800 
        if ftype == TType.I64:
10801 
          self.warehouseId = iprot.readI64();
10802 
        else:
10803 
          iprot.skip(ftype)
10804 
      else:
10805 
        iprot.skip(ftype)
10806 
      iprot.readFieldEnd()
10807 
    iprot.readStructEnd()
10808 
 
10809 
  def write(self, oprot):
10810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10812 
      return
10813 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 10814 
    if self.warehouseId is not None:
1220 chandransh 10815 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10816 
      oprot.writeI64(self.warehouseId)
10817 
      oprot.writeFieldEnd()
10818 
    oprot.writeFieldStop()
10819 
    oprot.writeStructEnd()
10820 
 
3431 rajveer 10821 
  def validate(self):
10822 
    return
10823 
 
10824 
 
1220 chandransh 10825 
  def __repr__(self):
10826 
    L = ['%s=%r' % (key, value)
10827 
      for key, value in self.__dict__.iteritems()]
10828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10829 
 
10830 
  def __eq__(self, other):
10831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10832 
 
10833 
  def __ne__(self, other):
10834 
    return not (self == other)
10835 
 
10836 
class batchOrders_result:
10837 
  """
10838 
  Attributes:
10839 
   - success
10840 
   - ex
10841 
  """
10842 
 
10843 
  thrift_spec = (
10844 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10845 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10846 
  )
10847 
 
10848 
  def __init__(self, success=None, ex=None,):
10849 
    self.success = success
10850 
    self.ex = ex
10851 
 
10852 
  def read(self, iprot):
10853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10855 
      return
10856 
    iprot.readStructBegin()
10857 
    while True:
10858 
      (fname, ftype, fid) = iprot.readFieldBegin()
10859 
      if ftype == TType.STOP:
10860 
        break
10861 
      if fid == 0:
10862 
        if ftype == TType.LIST:
10863 
          self.success = []
5031 varun.gupt 10864 
          (_etype206, _size203) = iprot.readListBegin()
10865 
          for _i207 in xrange(_size203):
10866 
            _elem208 = Order()
10867 
            _elem208.read(iprot)
10868 
            self.success.append(_elem208)
1220 chandransh 10869 
          iprot.readListEnd()
10870 
        else:
10871 
          iprot.skip(ftype)
10872 
      elif fid == 1:
10873 
        if ftype == TType.STRUCT:
10874 
          self.ex = TransactionServiceException()
10875 
          self.ex.read(iprot)
10876 
        else:
10877 
          iprot.skip(ftype)
10878 
      else:
10879 
        iprot.skip(ftype)
10880 
      iprot.readFieldEnd()
10881 
    iprot.readStructEnd()
10882 
 
10883 
  def write(self, oprot):
10884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10886 
      return
10887 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 10888 
    if self.success is not None:
1220 chandransh 10889 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10890 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10891 
      for iter209 in self.success:
10892 
        iter209.write(oprot)
1220 chandransh 10893 
      oprot.writeListEnd()
10894 
      oprot.writeFieldEnd()
3431 rajveer 10895 
    if self.ex is not None:
1220 chandransh 10896 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10897 
      self.ex.write(oprot)
10898 
      oprot.writeFieldEnd()
10899 
    oprot.writeFieldStop()
10900 
    oprot.writeStructEnd()
10901 
 
3431 rajveer 10902 
  def validate(self):
10903 
    return
10904 
 
10905 
 
1220 chandransh 10906 
  def __repr__(self):
10907 
    L = ['%s=%r' % (key, value)
10908 
      for key, value in self.__dict__.iteritems()]
10909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10910 
 
10911 
  def __eq__(self, other):
10912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10913 
 
10914 
  def __ne__(self, other):
10915 
    return not (self == other)
10916 
 
1208 chandransh 10917 
class markOrderAsOutOfStock_args:
10918 
  """
10919 
  Attributes:
10920 
   - orderId
10921 
  """
10922 
 
10923 
  thrift_spec = (
10924 
    None, # 0
10925 
    (1, TType.I64, 'orderId', None, None, ), # 1
10926 
  )
10927 
 
10928 
  def __init__(self, orderId=None,):
10929 
    self.orderId = orderId
10930 
 
10931 
  def read(self, iprot):
10932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10934 
      return
10935 
    iprot.readStructBegin()
10936 
    while True:
10937 
      (fname, ftype, fid) = iprot.readFieldBegin()
10938 
      if ftype == TType.STOP:
10939 
        break
10940 
      if fid == 1:
10941 
        if ftype == TType.I64:
10942 
          self.orderId = iprot.readI64();
10943 
        else:
10944 
          iprot.skip(ftype)
10945 
      else:
10946 
        iprot.skip(ftype)
10947 
      iprot.readFieldEnd()
10948 
    iprot.readStructEnd()
10949 
 
10950 
  def write(self, oprot):
10951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10953 
      return
10954 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 10955 
    if self.orderId is not None:
1208 chandransh 10956 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10957 
      oprot.writeI64(self.orderId)
10958 
      oprot.writeFieldEnd()
10959 
    oprot.writeFieldStop()
10960 
    oprot.writeStructEnd()
10961 
 
3431 rajveer 10962 
  def validate(self):
10963 
    return
10964 
 
10965 
 
1208 chandransh 10966 
  def __repr__(self):
10967 
    L = ['%s=%r' % (key, value)
10968 
      for key, value in self.__dict__.iteritems()]
10969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10970 
 
10971 
  def __eq__(self, other):
10972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10973 
 
10974 
  def __ne__(self, other):
10975 
    return not (self == other)
10976 
 
10977 
class markOrderAsOutOfStock_result:
10978 
  """
10979 
  Attributes:
10980 
   - success
10981 
   - ex
10982 
  """
10983 
 
10984 
  thrift_spec = (
10985 
    (0, TType.BOOL, 'success', None, None, ), # 0
10986 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10987 
  )
10988 
 
10989 
  def __init__(self, success=None, ex=None,):
10990 
    self.success = success
10991 
    self.ex = ex
10992 
 
10993 
  def read(self, iprot):
10994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10996 
      return
10997 
    iprot.readStructBegin()
10998 
    while True:
10999 
      (fname, ftype, fid) = iprot.readFieldBegin()
11000 
      if ftype == TType.STOP:
11001 
        break
11002 
      if fid == 0:
11003 
        if ftype == TType.BOOL:
11004 
          self.success = iprot.readBool();
11005 
        else:
11006 
          iprot.skip(ftype)
11007 
      elif fid == 1:
11008 
        if ftype == TType.STRUCT:
11009 
          self.ex = TransactionServiceException()
11010 
          self.ex.read(iprot)
11011 
        else:
11012 
          iprot.skip(ftype)
11013 
      else:
11014 
        iprot.skip(ftype)
11015 
      iprot.readFieldEnd()
11016 
    iprot.readStructEnd()
11017 
 
11018 
  def write(self, oprot):
11019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11021 
      return
11022 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 11023 
    if self.success is not None:
1208 chandransh 11024 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11025 
      oprot.writeBool(self.success)
11026 
      oprot.writeFieldEnd()
3431 rajveer 11027 
    if self.ex is not None:
1208 chandransh 11028 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11029 
      self.ex.write(oprot)
11030 
      oprot.writeFieldEnd()
11031 
    oprot.writeFieldStop()
11032 
    oprot.writeStructEnd()
11033 
 
3431 rajveer 11034 
  def validate(self):
11035 
    return
11036 
 
11037 
 
1208 chandransh 11038 
  def __repr__(self):
11039 
    L = ['%s=%r' % (key, value)
11040 
      for key, value in self.__dict__.iteritems()]
11041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11042 
 
11043 
  def __eq__(self, other):
11044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11045 
 
11046 
  def __ne__(self, other):
11047 
    return not (self == other)
11048 
 
3064 chandransh 11049 
class verifyOrder_args:
759 chandransh 11050 
  """
11051 
  Attributes:
3064 chandransh 11052 
   - orderId
759 chandransh 11053 
  """
11054 
 
11055 
  thrift_spec = (
11056 
    None, # 0
3064 chandransh 11057 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 11058 
  )
11059 
 
3064 chandransh 11060 
  def __init__(self, orderId=None,):
11061 
    self.orderId = orderId
759 chandransh 11062 
 
11063 
  def read(self, iprot):
11064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11066 
      return
11067 
    iprot.readStructBegin()
11068 
    while True:
11069 
      (fname, ftype, fid) = iprot.readFieldBegin()
11070 
      if ftype == TType.STOP:
11071 
        break
11072 
      if fid == 1:
11073 
        if ftype == TType.I64:
3064 chandransh 11074 
          self.orderId = iprot.readI64();
759 chandransh 11075 
        else:
11076 
          iprot.skip(ftype)
11077 
      else:
11078 
        iprot.skip(ftype)
11079 
      iprot.readFieldEnd()
11080 
    iprot.readStructEnd()
11081 
 
11082 
  def write(self, oprot):
11083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11085 
      return
3064 chandransh 11086 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 11087 
    if self.orderId is not None:
3064 chandransh 11088 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11089 
      oprot.writeI64(self.orderId)
759 chandransh 11090 
      oprot.writeFieldEnd()
11091 
    oprot.writeFieldStop()
11092 
    oprot.writeStructEnd()
11093 
 
3431 rajveer 11094 
  def validate(self):
11095 
    return
11096 
 
11097 
 
759 chandransh 11098 
  def __repr__(self):
11099 
    L = ['%s=%r' % (key, value)
11100 
      for key, value in self.__dict__.iteritems()]
11101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11102 
 
11103 
  def __eq__(self, other):
11104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11105 
 
11106 
  def __ne__(self, other):
11107 
    return not (self == other)
11108 
 
3064 chandransh 11109 
class verifyOrder_result:
759 chandransh 11110 
  """
11111 
  Attributes:
11112 
   - success
11113 
   - ex
11114 
  """
11115 
 
11116 
  thrift_spec = (
11117 
    (0, TType.BOOL, 'success', None, None, ), # 0
11118 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11119 
  )
11120 
 
11121 
  def __init__(self, success=None, ex=None,):
11122 
    self.success = success
11123 
    self.ex = ex
11124 
 
11125 
  def read(self, iprot):
11126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11128 
      return
11129 
    iprot.readStructBegin()
11130 
    while True:
11131 
      (fname, ftype, fid) = iprot.readFieldBegin()
11132 
      if ftype == TType.STOP:
11133 
        break
11134 
      if fid == 0:
11135 
        if ftype == TType.BOOL:
11136 
          self.success = iprot.readBool();
11137 
        else:
11138 
          iprot.skip(ftype)
11139 
      elif fid == 1:
11140 
        if ftype == TType.STRUCT:
11141 
          self.ex = TransactionServiceException()
11142 
          self.ex.read(iprot)
11143 
        else:
11144 
          iprot.skip(ftype)
11145 
      else:
11146 
        iprot.skip(ftype)
11147 
      iprot.readFieldEnd()
11148 
    iprot.readStructEnd()
11149 
 
11150 
  def write(self, oprot):
11151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11153 
      return
3064 chandransh 11154 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 11155 
    if self.success is not None:
759 chandransh 11156 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11157 
      oprot.writeBool(self.success)
11158 
      oprot.writeFieldEnd()
3431 rajveer 11159 
    if self.ex is not None:
759 chandransh 11160 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11161 
      self.ex.write(oprot)
11162 
      oprot.writeFieldEnd()
11163 
    oprot.writeFieldStop()
11164 
    oprot.writeStructEnd()
11165 
 
3431 rajveer 11166 
  def validate(self):
11167 
    return
11168 
 
11169 
 
759 chandransh 11170 
  def __repr__(self):
11171 
    L = ['%s=%r' % (key, value)
11172 
      for key, value in self.__dict__.iteritems()]
11173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11174 
 
11175 
  def __eq__(self, other):
11176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11177 
 
11178 
  def __ne__(self, other):
11179 
    return not (self == other)
11180 
 
3064 chandransh 11181 
class acceptOrder_args:
1113 chandransh 11182 
  """
11183 
  Attributes:
3064 chandransh 11184 
   - orderId
1113 chandransh 11185 
  """
11186 
 
11187 
  thrift_spec = (
11188 
    None, # 0
3064 chandransh 11189 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 11190 
  )
11191 
 
3064 chandransh 11192 
  def __init__(self, orderId=None,):
11193 
    self.orderId = orderId
1113 chandransh 11194 
 
11195 
  def read(self, iprot):
11196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11198 
      return
11199 
    iprot.readStructBegin()
11200 
    while True:
11201 
      (fname, ftype, fid) = iprot.readFieldBegin()
11202 
      if ftype == TType.STOP:
11203 
        break
11204 
      if fid == 1:
11205 
        if ftype == TType.I64:
3064 chandransh 11206 
          self.orderId = iprot.readI64();
1113 chandransh 11207 
        else:
11208 
          iprot.skip(ftype)
11209 
      else:
11210 
        iprot.skip(ftype)
11211 
      iprot.readFieldEnd()
11212 
    iprot.readStructEnd()
11213 
 
11214 
  def write(self, oprot):
11215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11217 
      return
3064 chandransh 11218 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 11219 
    if self.orderId is not None:
3064 chandransh 11220 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11221 
      oprot.writeI64(self.orderId)
1113 chandransh 11222 
      oprot.writeFieldEnd()
11223 
    oprot.writeFieldStop()
11224 
    oprot.writeStructEnd()
11225 
 
3431 rajveer 11226 
  def validate(self):
11227 
    return
11228 
 
11229 
 
1113 chandransh 11230 
  def __repr__(self):
11231 
    L = ['%s=%r' % (key, value)
11232 
      for key, value in self.__dict__.iteritems()]
11233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11234 
 
11235 
  def __eq__(self, other):
11236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11237 
 
11238 
  def __ne__(self, other):
11239 
    return not (self == other)
11240 
 
3064 chandransh 11241 
class acceptOrder_result:
1113 chandransh 11242 
  """
11243 
  Attributes:
11244 
   - success
11245 
   - ex
11246 
  """
11247 
 
11248 
  thrift_spec = (
3064 chandransh 11249 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 11250 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11251 
  )
11252 
 
11253 
  def __init__(self, success=None, ex=None,):
11254 
    self.success = success
11255 
    self.ex = ex
11256 
 
11257 
  def read(self, iprot):
11258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11260 
      return
11261 
    iprot.readStructBegin()
11262 
    while True:
11263 
      (fname, ftype, fid) = iprot.readFieldBegin()
11264 
      if ftype == TType.STOP:
11265 
        break
11266 
      if fid == 0:
3064 chandransh 11267 
        if ftype == TType.BOOL:
11268 
          self.success = iprot.readBool();
1113 chandransh 11269 
        else:
11270 
          iprot.skip(ftype)
11271 
      elif fid == 1:
11272 
        if ftype == TType.STRUCT:
11273 
          self.ex = TransactionServiceException()
11274 
          self.ex.read(iprot)
11275 
        else:
11276 
          iprot.skip(ftype)
11277 
      else:
11278 
        iprot.skip(ftype)
11279 
      iprot.readFieldEnd()
11280 
    iprot.readStructEnd()
11281 
 
11282 
  def write(self, oprot):
11283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11285 
      return
3064 chandransh 11286 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 11287 
    if self.success is not None:
3064 chandransh 11288 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11289 
      oprot.writeBool(self.success)
1113 chandransh 11290 
      oprot.writeFieldEnd()
3431 rajveer 11291 
    if self.ex is not None:
1113 chandransh 11292 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11293 
      self.ex.write(oprot)
11294 
      oprot.writeFieldEnd()
11295 
    oprot.writeFieldStop()
11296 
    oprot.writeStructEnd()
11297 
 
3431 rajveer 11298 
  def validate(self):
11299 
    return
11300 
 
11301 
 
1113 chandransh 11302 
  def __repr__(self):
11303 
    L = ['%s=%r' % (key, value)
11304 
      for key, value in self.__dict__.iteritems()]
11305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11306 
 
11307 
  def __eq__(self, other):
11308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11309 
 
11310 
  def __ne__(self, other):
11311 
    return not (self == other)
11312 
 
3064 chandransh 11313 
class addBillingDetails_args:
1135 chandransh 11314 
  """
11315 
  Attributes:
3064 chandransh 11316 
   - orderId
11317 
   - invoice_number
4658 mandeep.dh 11318 
   - serialNumber
4283 anupam.sin 11319 
   - itemNumber
3064 chandransh 11320 
   - billed_by
4264 rajveer 11321 
   - jacketNumber
4283 anupam.sin 11322 
   - billingType
5110 mandeep.dh 11323 
   - fulfilmentWarehouseId
4763 rajveer 11324 
   - authorize
1135 chandransh 11325 
  """
11326 
 
11327 
  thrift_spec = (
11328 
    None, # 0
3064 chandransh 11329 
    (1, TType.I64, 'orderId', None, None, ), # 1
11330 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 11331 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 11332 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
11333 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
11334 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
11335 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 11336 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 11337 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 11338 
  )
11339 
 
5110 mandeep.dh 11340 
  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 11341 
    self.orderId = orderId
11342 
    self.invoice_number = invoice_number
4658 mandeep.dh 11343 
    self.serialNumber = serialNumber
4283 anupam.sin 11344 
    self.itemNumber = itemNumber
3064 chandransh 11345 
    self.billed_by = billed_by
4264 rajveer 11346 
    self.jacketNumber = jacketNumber
4283 anupam.sin 11347 
    self.billingType = billingType
5110 mandeep.dh 11348 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 11349 
    self.authorize = authorize
1135 chandransh 11350 
 
11351 
  def read(self, iprot):
11352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11354 
      return
11355 
    iprot.readStructBegin()
11356 
    while True:
11357 
      (fname, ftype, fid) = iprot.readFieldBegin()
11358 
      if ftype == TType.STOP:
11359 
        break
11360 
      if fid == 1:
11361 
        if ftype == TType.I64:
3064 chandransh 11362 
          self.orderId = iprot.readI64();
1135 chandransh 11363 
        else:
11364 
          iprot.skip(ftype)
11365 
      elif fid == 2:
3064 chandransh 11366 
        if ftype == TType.STRING:
11367 
          self.invoice_number = iprot.readString();
1135 chandransh 11368 
        else:
11369 
          iprot.skip(ftype)
3064 chandransh 11370 
      elif fid == 3:
4658 mandeep.dh 11371 
        if ftype == TType.STRING:
11372 
          self.serialNumber = iprot.readString();
3064 chandransh 11373 
        else:
11374 
          iprot.skip(ftype)
11375 
      elif fid == 4:
11376 
        if ftype == TType.STRING:
11377 
          self.itemNumber = iprot.readString();
11378 
        else:
11379 
          iprot.skip(ftype)
11380 
      elif fid == 5:
11381 
        if ftype == TType.STRING:
4283 anupam.sin 11382 
          self.billed_by = iprot.readString();
3064 chandransh 11383 
        else:
11384 
          iprot.skip(ftype)
11385 
      elif fid == 6:
11386 
        if ftype == TType.I64:
4283 anupam.sin 11387 
          self.jacketNumber = iprot.readI64();
11388 
        else:
11389 
          iprot.skip(ftype)
11390 
      elif fid == 7:
11391 
        if ftype == TType.I64:
3064 chandransh 11392 
          self.billingType = iprot.readI64();
11393 
        else:
11394 
          iprot.skip(ftype)
4283 anupam.sin 11395 
      elif fid == 8:
11396 
        if ftype == TType.I64:
5110 mandeep.dh 11397 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 11398 
        else:
11399 
          iprot.skip(ftype)
4763 rajveer 11400 
      elif fid == 9:
11401 
        if ftype == TType.BOOL:
11402 
          self.authorize = iprot.readBool();
11403 
        else:
11404 
          iprot.skip(ftype)
1246 chandransh 11405 
      else:
11406 
        iprot.skip(ftype)
11407 
      iprot.readFieldEnd()
11408 
    iprot.readStructEnd()
11409 
 
11410 
  def write(self, oprot):
11411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11413 
      return
4283 anupam.sin 11414 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 11415 
    if self.orderId is not None:
3064 chandransh 11416 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11417 
      oprot.writeI64(self.orderId)
1246 chandransh 11418 
      oprot.writeFieldEnd()
4283 anupam.sin 11419 
    if self.invoice_number is not None:
11420 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
11421 
      oprot.writeString(self.invoice_number)
1246 chandransh 11422 
      oprot.writeFieldEnd()
4658 mandeep.dh 11423 
    if self.serialNumber is not None:
11424 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
11425 
      oprot.writeString(self.serialNumber)
3064 chandransh 11426 
      oprot.writeFieldEnd()
3431 rajveer 11427 
    if self.itemNumber is not None:
3064 chandransh 11428 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
11429 
      oprot.writeString(self.itemNumber)
11430 
      oprot.writeFieldEnd()
4283 anupam.sin 11431 
    if self.billed_by is not None:
11432 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
11433 
      oprot.writeString(self.billed_by)
3064 chandransh 11434 
      oprot.writeFieldEnd()
4283 anupam.sin 11435 
    if self.jacketNumber is not None:
11436 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
11437 
      oprot.writeI64(self.jacketNumber)
11438 
      oprot.writeFieldEnd()
3431 rajveer 11439 
    if self.billingType is not None:
4283 anupam.sin 11440 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 11441 
      oprot.writeI64(self.billingType)
11442 
      oprot.writeFieldEnd()
5110 mandeep.dh 11443 
    if self.fulfilmentWarehouseId is not None:
11444 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
11445 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 11446 
      oprot.writeFieldEnd()
4763 rajveer 11447 
    if self.authorize is not None:
11448 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
11449 
      oprot.writeBool(self.authorize)
11450 
      oprot.writeFieldEnd()
1246 chandransh 11451 
    oprot.writeFieldStop()
11452 
    oprot.writeStructEnd()
11453 
 
3431 rajveer 11454 
  def validate(self):
11455 
    return
11456 
 
11457 
 
1246 chandransh 11458 
  def __repr__(self):
11459 
    L = ['%s=%r' % (key, value)
11460 
      for key, value in self.__dict__.iteritems()]
11461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11462 
 
11463 
  def __eq__(self, other):
11464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11465 
 
11466 
  def __ne__(self, other):
11467 
    return not (self == other)
11468 
 
4283 anupam.sin 11469 
class addBillingDetails_result:
1246 chandransh 11470 
  """
11471 
  Attributes:
3064 chandransh 11472 
   - success
1246 chandransh 11473 
   - ex
11474 
  """
11475 
 
11476 
  thrift_spec = (
3064 chandransh 11477 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 11478 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11479 
  )
11480 
 
3064 chandransh 11481 
  def __init__(self, success=None, ex=None,):
11482 
    self.success = success
1246 chandransh 11483 
    self.ex = ex
11484 
 
11485 
  def read(self, iprot):
11486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11488 
      return
11489 
    iprot.readStructBegin()
11490 
    while True:
11491 
      (fname, ftype, fid) = iprot.readFieldBegin()
11492 
      if ftype == TType.STOP:
11493 
        break
3064 chandransh 11494 
      if fid == 0:
11495 
        if ftype == TType.BOOL:
11496 
          self.success = iprot.readBool();
11497 
        else:
11498 
          iprot.skip(ftype)
11499 
      elif fid == 1:
1246 chandransh 11500 
        if ftype == TType.STRUCT:
11501 
          self.ex = TransactionServiceException()
11502 
          self.ex.read(iprot)
11503 
        else:
11504 
          iprot.skip(ftype)
11505 
      else:
11506 
        iprot.skip(ftype)
11507 
      iprot.readFieldEnd()
11508 
    iprot.readStructEnd()
11509 
 
11510 
  def write(self, oprot):
11511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11513 
      return
4283 anupam.sin 11514 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 11515 
    if self.success is not None:
3064 chandransh 11516 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11517 
      oprot.writeBool(self.success)
11518 
      oprot.writeFieldEnd()
3431 rajveer 11519 
    if self.ex is not None:
1246 chandransh 11520 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11521 
      self.ex.write(oprot)
11522 
      oprot.writeFieldEnd()
11523 
    oprot.writeFieldStop()
11524 
    oprot.writeStructEnd()
11525 
 
3431 rajveer 11526 
  def validate(self):
11527 
    return
11528 
 
11529 
 
1246 chandransh 11530 
  def __repr__(self):
11531 
    L = ['%s=%r' % (key, value)
11532 
      for key, value in self.__dict__.iteritems()]
11533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11534 
 
11535 
  def __eq__(self, other):
11536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11537 
 
11538 
  def __ne__(self, other):
11539 
    return not (self == other)
11540 
 
4579 rajveer 11541 
class addInvoiceNumber_args:
11542 
  """
11543 
  Attributes:
11544 
   - orderId
11545 
   - invoiceNumber
4763 rajveer 11546 
   - color
4579 rajveer 11547 
  """
11548 
 
11549 
  thrift_spec = (
11550 
    None, # 0
11551 
    (1, TType.I64, 'orderId', None, None, ), # 1
11552 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 11553 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 11554 
  )
11555 
 
4763 rajveer 11556 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 11557 
    self.orderId = orderId
11558 
    self.invoiceNumber = invoiceNumber
4763 rajveer 11559 
    self.color = color
4579 rajveer 11560 
 
11561 
  def read(self, iprot):
11562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11564 
      return
11565 
    iprot.readStructBegin()
11566 
    while True:
11567 
      (fname, ftype, fid) = iprot.readFieldBegin()
11568 
      if ftype == TType.STOP:
11569 
        break
11570 
      if fid == 1:
11571 
        if ftype == TType.I64:
11572 
          self.orderId = iprot.readI64();
11573 
        else:
11574 
          iprot.skip(ftype)
11575 
      elif fid == 2:
11576 
        if ftype == TType.STRING:
11577 
          self.invoiceNumber = iprot.readString();
11578 
        else:
11579 
          iprot.skip(ftype)
4763 rajveer 11580 
      elif fid == 3:
11581 
        if ftype == TType.STRING:
11582 
          self.color = iprot.readString();
11583 
        else:
11584 
          iprot.skip(ftype)
4579 rajveer 11585 
      else:
11586 
        iprot.skip(ftype)
11587 
      iprot.readFieldEnd()
11588 
    iprot.readStructEnd()
11589 
 
11590 
  def write(self, oprot):
11591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11593 
      return
11594 
    oprot.writeStructBegin('addInvoiceNumber_args')
11595 
    if self.orderId is not None:
11596 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11597 
      oprot.writeI64(self.orderId)
11598 
      oprot.writeFieldEnd()
11599 
    if self.invoiceNumber is not None:
11600 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
11601 
      oprot.writeString(self.invoiceNumber)
11602 
      oprot.writeFieldEnd()
4763 rajveer 11603 
    if self.color is not None:
11604 
      oprot.writeFieldBegin('color', TType.STRING, 3)
11605 
      oprot.writeString(self.color)
11606 
      oprot.writeFieldEnd()
4579 rajveer 11607 
    oprot.writeFieldStop()
11608 
    oprot.writeStructEnd()
11609 
 
11610 
  def validate(self):
11611 
    return
11612 
 
11613 
 
11614 
  def __repr__(self):
11615 
    L = ['%s=%r' % (key, value)
11616 
      for key, value in self.__dict__.iteritems()]
11617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11618 
 
11619 
  def __eq__(self, other):
11620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11621 
 
11622 
  def __ne__(self, other):
11623 
    return not (self == other)
11624 
 
11625 
class addInvoiceNumber_result:
11626 
  """
11627 
  Attributes:
11628 
   - ex
11629 
  """
11630 
 
11631 
  thrift_spec = (
11632 
    None, # 0
11633 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11634 
  )
11635 
 
11636 
  def __init__(self, ex=None,):
11637 
    self.ex = ex
11638 
 
11639 
  def read(self, iprot):
11640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11642 
      return
11643 
    iprot.readStructBegin()
11644 
    while True:
11645 
      (fname, ftype, fid) = iprot.readFieldBegin()
11646 
      if ftype == TType.STOP:
11647 
        break
11648 
      if fid == 1:
11649 
        if ftype == TType.STRUCT:
11650 
          self.ex = TransactionServiceException()
11651 
          self.ex.read(iprot)
11652 
        else:
11653 
          iprot.skip(ftype)
11654 
      else:
11655 
        iprot.skip(ftype)
11656 
      iprot.readFieldEnd()
11657 
    iprot.readStructEnd()
11658 
 
11659 
  def write(self, oprot):
11660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11662 
      return
11663 
    oprot.writeStructBegin('addInvoiceNumber_result')
11664 
    if self.ex is not None:
11665 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11666 
      self.ex.write(oprot)
11667 
      oprot.writeFieldEnd()
11668 
    oprot.writeFieldStop()
11669 
    oprot.writeStructEnd()
11670 
 
11671 
  def validate(self):
11672 
    return
11673 
 
11674 
 
11675 
  def __repr__(self):
11676 
    L = ['%s=%r' % (key, value)
11677 
      for key, value in self.__dict__.iteritems()]
11678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11679 
 
11680 
  def __eq__(self, other):
11681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11682 
 
11683 
  def __ne__(self, other):
11684 
    return not (self == other)
11685 
 
4910 phani.kuma 11686 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 11687 
  """
11688 
  Attributes:
3064 chandransh 11689 
   - warehouseId
1408 ankur.sing 11690 
   - providerId
3064 chandransh 11691 
   - cod
4910 phani.kuma 11692 
   - orderIds
1408 ankur.sing 11693 
  """
11694 
 
11695 
  thrift_spec = (
11696 
    None, # 0
3064 chandransh 11697 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11698 
    (2, TType.I64, 'providerId', None, None, ), # 2
11699 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 11700 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 11701 
  )
11702 
 
4910 phani.kuma 11703 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 11704 
    self.warehouseId = warehouseId
1408 ankur.sing 11705 
    self.providerId = providerId
3064 chandransh 11706 
    self.cod = cod
4910 phani.kuma 11707 
    self.orderIds = orderIds
1408 ankur.sing 11708 
 
11709 
  def read(self, iprot):
11710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11712 
      return
11713 
    iprot.readStructBegin()
11714 
    while True:
11715 
      (fname, ftype, fid) = iprot.readFieldBegin()
11716 
      if ftype == TType.STOP:
11717 
        break
11718 
      if fid == 1:
11719 
        if ftype == TType.I64:
3064 chandransh 11720 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 11721 
        else:
11722 
          iprot.skip(ftype)
11723 
      elif fid == 2:
11724 
        if ftype == TType.I64:
3064 chandransh 11725 
          self.providerId = iprot.readI64();
1408 ankur.sing 11726 
        else:
11727 
          iprot.skip(ftype)
3064 chandransh 11728 
      elif fid == 3:
11729 
        if ftype == TType.BOOL:
11730 
          self.cod = iprot.readBool();
11731 
        else:
11732 
          iprot.skip(ftype)
4910 phani.kuma 11733 
      elif fid == 4:
11734 
        if ftype == TType.LIST:
11735 
          self.orderIds = []
5031 varun.gupt 11736 
          (_etype213, _size210) = iprot.readListBegin()
11737 
          for _i214 in xrange(_size210):
11738 
            _elem215 = iprot.readI64();
11739 
            self.orderIds.append(_elem215)
4910 phani.kuma 11740 
          iprot.readListEnd()
11741 
        else:
11742 
          iprot.skip(ftype)
1408 ankur.sing 11743 
      else:
11744 
        iprot.skip(ftype)
11745 
      iprot.readFieldEnd()
11746 
    iprot.readStructEnd()
11747 
 
11748 
  def write(self, oprot):
11749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11751 
      return
4910 phani.kuma 11752 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 11753 
    if self.warehouseId is not None:
3064 chandransh 11754 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11755 
      oprot.writeI64(self.warehouseId)
11756 
      oprot.writeFieldEnd()
3431 rajveer 11757 
    if self.providerId is not None:
3064 chandransh 11758 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 11759 
      oprot.writeI64(self.providerId)
11760 
      oprot.writeFieldEnd()
3431 rajveer 11761 
    if self.cod is not None:
3064 chandransh 11762 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
11763 
      oprot.writeBool(self.cod)
1408 ankur.sing 11764 
      oprot.writeFieldEnd()
4910 phani.kuma 11765 
    if self.orderIds is not None:
11766 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
11767 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5031 varun.gupt 11768 
      for iter216 in self.orderIds:
11769 
        oprot.writeI64(iter216)
4910 phani.kuma 11770 
      oprot.writeListEnd()
11771 
      oprot.writeFieldEnd()
1408 ankur.sing 11772 
    oprot.writeFieldStop()
11773 
    oprot.writeStructEnd()
11774 
 
3431 rajveer 11775 
  def validate(self):
11776 
    return
11777 
 
11778 
 
1408 ankur.sing 11779 
  def __repr__(self):
11780 
    L = ['%s=%r' % (key, value)
11781 
      for key, value in self.__dict__.iteritems()]
11782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11783 
 
11784 
  def __eq__(self, other):
11785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11786 
 
11787 
  def __ne__(self, other):
11788 
    return not (self == other)
11789 
 
4910 phani.kuma 11790 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 11791 
  """
11792 
  Attributes:
11793 
   - success
3064 chandransh 11794 
   - ex
1408 ankur.sing 11795 
  """
11796 
 
11797 
  thrift_spec = (
3064 chandransh 11798 
    (0, TType.BOOL, 'success', None, None, ), # 0
11799 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 11800 
  )
11801 
 
3064 chandransh 11802 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 11803 
    self.success = success
3064 chandransh 11804 
    self.ex = ex
1408 ankur.sing 11805 
 
11806 
  def read(self, iprot):
11807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11809 
      return
11810 
    iprot.readStructBegin()
11811 
    while True:
11812 
      (fname, ftype, fid) = iprot.readFieldBegin()
11813 
      if ftype == TType.STOP:
11814 
        break
11815 
      if fid == 0:
3064 chandransh 11816 
        if ftype == TType.BOOL:
11817 
          self.success = iprot.readBool();
1408 ankur.sing 11818 
        else:
11819 
          iprot.skip(ftype)
3064 chandransh 11820 
      elif fid == 1:
11821 
        if ftype == TType.STRUCT:
11822 
          self.ex = TransactionServiceException()
11823 
          self.ex.read(iprot)
11824 
        else:
11825 
          iprot.skip(ftype)
1408 ankur.sing 11826 
      else:
11827 
        iprot.skip(ftype)
11828 
      iprot.readFieldEnd()
11829 
    iprot.readStructEnd()
11830 
 
11831 
  def write(self, oprot):
11832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11834 
      return
4910 phani.kuma 11835 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 11836 
    if self.success is not None:
3064 chandransh 11837 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11838 
      oprot.writeBool(self.success)
1408 ankur.sing 11839 
      oprot.writeFieldEnd()
3431 rajveer 11840 
    if self.ex is not None:
3064 chandransh 11841 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11842 
      self.ex.write(oprot)
11843 
      oprot.writeFieldEnd()
1408 ankur.sing 11844 
    oprot.writeFieldStop()
11845 
    oprot.writeStructEnd()
11846 
 
3431 rajveer 11847 
  def validate(self):
11848 
    return
11849 
 
11850 
 
1408 ankur.sing 11851 
  def __repr__(self):
11852 
    L = ['%s=%r' % (key, value)
11853 
      for key, value in self.__dict__.iteritems()]
11854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11855 
 
11856 
  def __eq__(self, other):
11857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11858 
 
11859 
  def __ne__(self, other):
11860 
    return not (self == other)
11861 
 
4910 phani.kuma 11862 
class markOrdersAsPickedUp_args:
4410 rajveer 11863 
  """
11864 
  Attributes:
11865 
   - providerId
4910 phani.kuma 11866 
   - pickupDetails
4410 rajveer 11867 
  """
11868 
 
11869 
  thrift_spec = (
11870 
    None, # 0
4910 phani.kuma 11871 
    (1, TType.I64, 'providerId', None, None, ), # 1
11872 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 11873 
  )
11874 
 
4910 phani.kuma 11875 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 11876 
    self.providerId = providerId
4910 phani.kuma 11877 
    self.pickupDetails = pickupDetails
4410 rajveer 11878 
 
11879 
  def read(self, iprot):
11880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11882 
      return
11883 
    iprot.readStructBegin()
11884 
    while True:
11885 
      (fname, ftype, fid) = iprot.readFieldBegin()
11886 
      if ftype == TType.STOP:
11887 
        break
11888 
      if fid == 1:
11889 
        if ftype == TType.I64:
4910 phani.kuma 11890 
          self.providerId = iprot.readI64();
4410 rajveer 11891 
        else:
11892 
          iprot.skip(ftype)
11893 
      elif fid == 2:
4910 phani.kuma 11894 
        if ftype == TType.MAP:
11895 
          self.pickupDetails = {}
5031 varun.gupt 11896 
          (_ktype218, _vtype219, _size217 ) = iprot.readMapBegin()
11897 
          for _i221 in xrange(_size217):
11898 
            _key222 = iprot.readString();
11899 
            _val223 = iprot.readString();
11900 
            self.pickupDetails[_key222] = _val223
4910 phani.kuma 11901 
          iprot.readMapEnd()
4410 rajveer 11902 
        else:
11903 
          iprot.skip(ftype)
11904 
      else:
11905 
        iprot.skip(ftype)
11906 
      iprot.readFieldEnd()
11907 
    iprot.readStructEnd()
11908 
 
11909 
  def write(self, oprot):
11910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11912 
      return
4910 phani.kuma 11913 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 11914 
    if self.providerId is not None:
4910 phani.kuma 11915 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 11916 
      oprot.writeI64(self.providerId)
11917 
      oprot.writeFieldEnd()
4910 phani.kuma 11918 
    if self.pickupDetails is not None:
11919 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11920 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 11921 
      for kiter224,viter225 in self.pickupDetails.items():
11922 
        oprot.writeString(kiter224)
11923 
        oprot.writeString(viter225)
4910 phani.kuma 11924 
      oprot.writeMapEnd()
4410 rajveer 11925 
      oprot.writeFieldEnd()
11926 
    oprot.writeFieldStop()
11927 
    oprot.writeStructEnd()
11928 
 
11929 
  def validate(self):
11930 
    return
11931 
 
11932 
 
11933 
  def __repr__(self):
11934 
    L = ['%s=%r' % (key, value)
11935 
      for key, value in self.__dict__.iteritems()]
11936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11937 
 
11938 
  def __eq__(self, other):
11939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11940 
 
11941 
  def __ne__(self, other):
11942 
    return not (self == other)
11943 
 
4910 phani.kuma 11944 
class markOrdersAsPickedUp_result:
4410 rajveer 11945 
  """
11946 
  Attributes:
11947 
   - ex
11948 
  """
11949 
 
11950 
  thrift_spec = (
4910 phani.kuma 11951 
    None, # 0
4410 rajveer 11952 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11953 
  )
11954 
 
4910 phani.kuma 11955 
  def __init__(self, ex=None,):
4410 rajveer 11956 
    self.ex = ex
11957 
 
11958 
  def read(self, iprot):
11959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11961 
      return
11962 
    iprot.readStructBegin()
11963 
    while True:
11964 
      (fname, ftype, fid) = iprot.readFieldBegin()
11965 
      if ftype == TType.STOP:
11966 
        break
4910 phani.kuma 11967 
      if fid == 1:
4410 rajveer 11968 
        if ftype == TType.STRUCT:
11969 
          self.ex = TransactionServiceException()
11970 
          self.ex.read(iprot)
11971 
        else:
11972 
          iprot.skip(ftype)
11973 
      else:
11974 
        iprot.skip(ftype)
11975 
      iprot.readFieldEnd()
11976 
    iprot.readStructEnd()
11977 
 
11978 
  def write(self, oprot):
11979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11981 
      return
4910 phani.kuma 11982 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 11983 
    if self.ex is not None:
11984 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11985 
      self.ex.write(oprot)
11986 
      oprot.writeFieldEnd()
11987 
    oprot.writeFieldStop()
11988 
    oprot.writeStructEnd()
11989 
 
11990 
  def validate(self):
11991 
    return
11992 
 
11993 
 
11994 
  def __repr__(self):
11995 
    L = ['%s=%r' % (key, value)
11996 
      for key, value in self.__dict__.iteritems()]
11997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11998 
 
11999 
  def __eq__(self, other):
12000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12001 
 
12002 
  def __ne__(self, other):
12003 
    return not (self == other)
12004 
 
4910 phani.kuma 12005 
class getOrdersNotPickedUp_args:
304 ashish 12006 
  """
12007 
  Attributes:
3064 chandransh 12008 
   - providerId
304 ashish 12009 
  """
94 ashish 12010 
 
304 ashish 12011 
  thrift_spec = (
12012 
    None, # 0
3064 chandransh 12013 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 12014 
  )
12015 
 
4910 phani.kuma 12016 
  def __init__(self, providerId=None,):
3064 chandransh 12017 
    self.providerId = providerId
304 ashish 12018 
 
12019 
  def read(self, iprot):
12020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12022 
      return
12023 
    iprot.readStructBegin()
12024 
    while True:
12025 
      (fname, ftype, fid) = iprot.readFieldBegin()
12026 
      if ftype == TType.STOP:
12027 
        break
12028 
      if fid == 1:
12029 
        if ftype == TType.I64:
3064 chandransh 12030 
          self.providerId = iprot.readI64();
304 ashish 12031 
        else:
12032 
          iprot.skip(ftype)
12033 
      else:
12034 
        iprot.skip(ftype)
12035 
      iprot.readFieldEnd()
12036 
    iprot.readStructEnd()
12037 
 
12038 
  def write(self, oprot):
12039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12041 
      return
4910 phani.kuma 12042 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 12043 
    if self.providerId is not None:
3064 chandransh 12044 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12045 
      oprot.writeI64(self.providerId)
304 ashish 12046 
      oprot.writeFieldEnd()
12047 
    oprot.writeFieldStop()
12048 
    oprot.writeStructEnd()
12049 
 
3431 rajveer 12050 
  def validate(self):
12051 
    return
12052 
 
12053 
 
304 ashish 12054 
  def __repr__(self):
12055 
    L = ['%s=%r' % (key, value)
12056 
      for key, value in self.__dict__.iteritems()]
12057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12058 
 
12059 
  def __eq__(self, other):
12060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12061 
 
12062 
  def __ne__(self, other):
12063 
    return not (self == other)
12064 
 
4910 phani.kuma 12065 
class getOrdersNotPickedUp_result:
304 ashish 12066 
  """
12067 
  Attributes:
12068 
   - success
12069 
  """
12070 
 
12071 
  thrift_spec = (
3064 chandransh 12072 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 12073 
  )
12074 
 
4910 phani.kuma 12075 
  def __init__(self, success=None,):
304 ashish 12076 
    self.success = success
12077 
 
12078 
  def read(self, iprot):
12079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12081 
      return
12082 
    iprot.readStructBegin()
12083 
    while True:
12084 
      (fname, ftype, fid) = iprot.readFieldBegin()
12085 
      if ftype == TType.STOP:
12086 
        break
12087 
      if fid == 0:
12088 
        if ftype == TType.LIST:
12089 
          self.success = []
5031 varun.gupt 12090 
          (_etype229, _size226) = iprot.readListBegin()
12091 
          for _i230 in xrange(_size226):
12092 
            _elem231 = Order()
12093 
            _elem231.read(iprot)
12094 
            self.success.append(_elem231)
304 ashish 12095 
          iprot.readListEnd()
12096 
        else:
12097 
          iprot.skip(ftype)
12098 
      else:
12099 
        iprot.skip(ftype)
12100 
      iprot.readFieldEnd()
12101 
    iprot.readStructEnd()
12102 
 
12103 
  def write(self, oprot):
12104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12106 
      return
4910 phani.kuma 12107 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 12108 
    if self.success is not None:
304 ashish 12109 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12110 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12111 
      for iter232 in self.success:
12112 
        iter232.write(oprot)
304 ashish 12113 
      oprot.writeListEnd()
12114 
      oprot.writeFieldEnd()
12115 
    oprot.writeFieldStop()
12116 
    oprot.writeStructEnd()
12117 
 
3431 rajveer 12118 
  def validate(self):
12119 
    return
12120 
 
12121 
 
304 ashish 12122 
  def __repr__(self):
12123 
    L = ['%s=%r' % (key, value)
12124 
      for key, value in self.__dict__.iteritems()]
12125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12126 
 
12127 
  def __eq__(self, other):
12128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12129 
 
12130 
  def __ne__(self, other):
12131 
    return not (self == other)
12132 
 
3064 chandransh 12133 
class markOrdersAsDelivered_args:
304 ashish 12134 
  """
12135 
  Attributes:
3064 chandransh 12136 
   - providerId
12137 
   - deliveredOrders
304 ashish 12138 
  """
12139 
 
12140 
  thrift_spec = (
12141 
    None, # 0
3064 chandransh 12142 
    (1, TType.I64, 'providerId', None, None, ), # 1
12143 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 12144 
  )
12145 
 
3064 chandransh 12146 
  def __init__(self, providerId=None, deliveredOrders=None,):
12147 
    self.providerId = providerId
12148 
    self.deliveredOrders = deliveredOrders
304 ashish 12149 
 
12150 
  def read(self, iprot):
12151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12153 
      return
12154 
    iprot.readStructBegin()
12155 
    while True:
12156 
      (fname, ftype, fid) = iprot.readFieldBegin()
12157 
      if ftype == TType.STOP:
12158 
        break
12159 
      if fid == 1:
12160 
        if ftype == TType.I64:
3064 chandransh 12161 
          self.providerId = iprot.readI64();
304 ashish 12162 
        else:
12163 
          iprot.skip(ftype)
12164 
      elif fid == 2:
3064 chandransh 12165 
        if ftype == TType.MAP:
12166 
          self.deliveredOrders = {}
5031 varun.gupt 12167 
          (_ktype234, _vtype235, _size233 ) = iprot.readMapBegin()
12168 
          for _i237 in xrange(_size233):
12169 
            _key238 = iprot.readString();
12170 
            _val239 = iprot.readString();
12171 
            self.deliveredOrders[_key238] = _val239
3064 chandransh 12172 
          iprot.readMapEnd()
304 ashish 12173 
        else:
12174 
          iprot.skip(ftype)
12175 
      else:
12176 
        iprot.skip(ftype)
12177 
      iprot.readFieldEnd()
12178 
    iprot.readStructEnd()
12179 
 
12180 
  def write(self, oprot):
12181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12183 
      return
3064 chandransh 12184 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 12185 
    if self.providerId is not None:
3064 chandransh 12186 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12187 
      oprot.writeI64(self.providerId)
304 ashish 12188 
      oprot.writeFieldEnd()
3431 rajveer 12189 
    if self.deliveredOrders is not None:
3064 chandransh 12190 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
12191 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
5031 varun.gupt 12192 
      for kiter240,viter241 in self.deliveredOrders.items():
12193 
        oprot.writeString(kiter240)
12194 
        oprot.writeString(viter241)
3064 chandransh 12195 
      oprot.writeMapEnd()
304 ashish 12196 
      oprot.writeFieldEnd()
12197 
    oprot.writeFieldStop()
12198 
    oprot.writeStructEnd()
12199 
 
3431 rajveer 12200 
  def validate(self):
12201 
    return
12202 
 
12203 
 
304 ashish 12204 
  def __repr__(self):
12205 
    L = ['%s=%r' % (key, value)
12206 
      for key, value in self.__dict__.iteritems()]
12207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12208 
 
12209 
  def __eq__(self, other):
12210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12211 
 
12212 
  def __ne__(self, other):
12213 
    return not (self == other)
12214 
 
3064 chandransh 12215 
class markOrdersAsDelivered_result:
12216 
  """
12217 
  Attributes:
12218 
   - ex
12219 
  """
304 ashish 12220 
 
12221 
  thrift_spec = (
3064 chandransh 12222 
    None, # 0
12223 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 12224 
  )
12225 
 
3064 chandransh 12226 
  def __init__(self, ex=None,):
12227 
    self.ex = ex
304 ashish 12228 
 
1596 ankur.sing 12229 
  def read(self, iprot):
12230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12232 
      return
12233 
    iprot.readStructBegin()
12234 
    while True:
12235 
      (fname, ftype, fid) = iprot.readFieldBegin()
12236 
      if ftype == TType.STOP:
12237 
        break
3064 chandransh 12238 
      if fid == 1:
12239 
        if ftype == TType.STRUCT:
12240 
          self.ex = TransactionServiceException()
12241 
          self.ex.read(iprot)
12242 
        else:
12243 
          iprot.skip(ftype)
1596 ankur.sing 12244 
      else:
12245 
        iprot.skip(ftype)
12246 
      iprot.readFieldEnd()
12247 
    iprot.readStructEnd()
12248 
 
12249 
  def write(self, oprot):
12250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12252 
      return
3064 chandransh 12253 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 12254 
    if self.ex is not None:
3064 chandransh 12255 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12256 
      self.ex.write(oprot)
12257 
      oprot.writeFieldEnd()
1596 ankur.sing 12258 
    oprot.writeFieldStop()
12259 
    oprot.writeStructEnd()
12260 
 
3431 rajveer 12261 
  def validate(self):
12262 
    return
12263 
 
12264 
 
1596 ankur.sing 12265 
  def __repr__(self):
12266 
    L = ['%s=%r' % (key, value)
12267 
      for key, value in self.__dict__.iteritems()]
12268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12269 
 
12270 
  def __eq__(self, other):
12271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12272 
 
12273 
  def __ne__(self, other):
12274 
    return not (self == other)
12275 
 
4910 phani.kuma 12276 
class markAsRTOrders_args:
1596 ankur.sing 12277 
  """
12278 
  Attributes:
3064 chandransh 12279 
   - providerId
12280 
   - returnedOrders
1596 ankur.sing 12281 
  """
12282 
 
12283 
  thrift_spec = (
3064 chandransh 12284 
    None, # 0
12285 
    (1, TType.I64, 'providerId', None, None, ), # 1
12286 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 12287 
  )
12288 
 
3064 chandransh 12289 
  def __init__(self, providerId=None, returnedOrders=None,):
12290 
    self.providerId = providerId
12291 
    self.returnedOrders = returnedOrders
1596 ankur.sing 12292 
 
12293 
  def read(self, iprot):
12294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12296 
      return
12297 
    iprot.readStructBegin()
12298 
    while True:
12299 
      (fname, ftype, fid) = iprot.readFieldBegin()
12300 
      if ftype == TType.STOP:
12301 
        break
3064 chandransh 12302 
      if fid == 1:
1596 ankur.sing 12303 
        if ftype == TType.I64:
3064 chandransh 12304 
          self.providerId = iprot.readI64();
1596 ankur.sing 12305 
        else:
12306 
          iprot.skip(ftype)
3064 chandransh 12307 
      elif fid == 2:
12308 
        if ftype == TType.MAP:
12309 
          self.returnedOrders = {}
5031 varun.gupt 12310 
          (_ktype243, _vtype244, _size242 ) = iprot.readMapBegin()
12311 
          for _i246 in xrange(_size242):
12312 
            _key247 = iprot.readString();
12313 
            _val248 = iprot.readString();
12314 
            self.returnedOrders[_key247] = _val248
3064 chandransh 12315 
          iprot.readMapEnd()
12316 
        else:
12317 
          iprot.skip(ftype)
1596 ankur.sing 12318 
      else:
12319 
        iprot.skip(ftype)
12320 
      iprot.readFieldEnd()
12321 
    iprot.readStructEnd()
12322 
 
12323 
  def write(self, oprot):
12324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12326 
      return
4910 phani.kuma 12327 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 12328 
    if self.providerId is not None:
3064 chandransh 12329 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12330 
      oprot.writeI64(self.providerId)
1596 ankur.sing 12331 
      oprot.writeFieldEnd()
3431 rajveer 12332 
    if self.returnedOrders is not None:
3064 chandransh 12333 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
12334 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
5031 varun.gupt 12335 
      for kiter249,viter250 in self.returnedOrders.items():
12336 
        oprot.writeString(kiter249)
12337 
        oprot.writeString(viter250)
3064 chandransh 12338 
      oprot.writeMapEnd()
12339 
      oprot.writeFieldEnd()
1596 ankur.sing 12340 
    oprot.writeFieldStop()
12341 
    oprot.writeStructEnd()
12342 
 
3431 rajveer 12343 
  def validate(self):
12344 
    return
12345 
 
12346 
 
1596 ankur.sing 12347 
  def __repr__(self):
12348 
    L = ['%s=%r' % (key, value)
12349 
      for key, value in self.__dict__.iteritems()]
12350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12351 
 
12352 
  def __eq__(self, other):
12353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12354 
 
12355 
  def __ne__(self, other):
12356 
    return not (self == other)
12357 
 
4910 phani.kuma 12358 
class markAsRTOrders_result:
3064 chandransh 12359 
  """
12360 
  Attributes:
12361 
   - ex
12362 
  """
1596 ankur.sing 12363 
 
1627 ankur.sing 12364 
  thrift_spec = (
3064 chandransh 12365 
    None, # 0
12366 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12367 
  )
12368 
 
3064 chandransh 12369 
  def __init__(self, ex=None,):
12370 
    self.ex = ex
12371 
 
1627 ankur.sing 12372 
  def read(self, iprot):
12373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12375 
      return
12376 
    iprot.readStructBegin()
12377 
    while True:
12378 
      (fname, ftype, fid) = iprot.readFieldBegin()
12379 
      if ftype == TType.STOP:
12380 
        break
3064 chandransh 12381 
      if fid == 1:
12382 
        if ftype == TType.STRUCT:
12383 
          self.ex = TransactionServiceException()
12384 
          self.ex.read(iprot)
12385 
        else:
12386 
          iprot.skip(ftype)
1627 ankur.sing 12387 
      else:
12388 
        iprot.skip(ftype)
12389 
      iprot.readFieldEnd()
12390 
    iprot.readStructEnd()
12391 
 
12392 
  def write(self, oprot):
12393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12395 
      return
4910 phani.kuma 12396 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 12397 
    if self.ex is not None:
3064 chandransh 12398 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12399 
      self.ex.write(oprot)
12400 
      oprot.writeFieldEnd()
1627 ankur.sing 12401 
    oprot.writeFieldStop()
12402 
    oprot.writeStructEnd()
12403 
 
3431 rajveer 12404 
  def validate(self):
12405 
    return
12406 
 
12407 
 
1627 ankur.sing 12408 
  def __repr__(self):
12409 
    L = ['%s=%r' % (key, value)
12410 
      for key, value in self.__dict__.iteritems()]
12411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12412 
 
12413 
  def __eq__(self, other):
12414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12415 
 
12416 
  def __ne__(self, other):
12417 
    return not (self == other)
12418 
 
4910 phani.kuma 12419 
class getRTOrders_args:
12420 
  """
12421 
  Attributes:
12422 
   - providerId
12423 
  """
12424 
 
12425 
  thrift_spec = (
12426 
    None, # 0
12427 
    (1, TType.I64, 'providerId', None, None, ), # 1
12428 
  )
12429 
 
12430 
  def __init__(self, providerId=None,):
12431 
    self.providerId = providerId
12432 
 
12433 
  def read(self, iprot):
12434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12436 
      return
12437 
    iprot.readStructBegin()
12438 
    while True:
12439 
      (fname, ftype, fid) = iprot.readFieldBegin()
12440 
      if ftype == TType.STOP:
12441 
        break
12442 
      if fid == 1:
12443 
        if ftype == TType.I64:
12444 
          self.providerId = iprot.readI64();
12445 
        else:
12446 
          iprot.skip(ftype)
12447 
      else:
12448 
        iprot.skip(ftype)
12449 
      iprot.readFieldEnd()
12450 
    iprot.readStructEnd()
12451 
 
12452 
  def write(self, oprot):
12453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12455 
      return
12456 
    oprot.writeStructBegin('getRTOrders_args')
12457 
    if self.providerId is not None:
12458 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12459 
      oprot.writeI64(self.providerId)
12460 
      oprot.writeFieldEnd()
12461 
    oprot.writeFieldStop()
12462 
    oprot.writeStructEnd()
12463 
 
12464 
  def validate(self):
12465 
    return
12466 
 
12467 
 
12468 
  def __repr__(self):
12469 
    L = ['%s=%r' % (key, value)
12470 
      for key, value in self.__dict__.iteritems()]
12471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12472 
 
12473 
  def __eq__(self, other):
12474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12475 
 
12476 
  def __ne__(self, other):
12477 
    return not (self == other)
12478 
 
12479 
class getRTOrders_result:
12480 
  """
12481 
  Attributes:
12482 
   - success
12483 
  """
12484 
 
12485 
  thrift_spec = (
12486 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12487 
  )
12488 
 
12489 
  def __init__(self, success=None,):
12490 
    self.success = success
12491 
 
12492 
  def read(self, iprot):
12493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12495 
      return
12496 
    iprot.readStructBegin()
12497 
    while True:
12498 
      (fname, ftype, fid) = iprot.readFieldBegin()
12499 
      if ftype == TType.STOP:
12500 
        break
12501 
      if fid == 0:
12502 
        if ftype == TType.LIST:
12503 
          self.success = []
5031 varun.gupt 12504 
          (_etype254, _size251) = iprot.readListBegin()
12505 
          for _i255 in xrange(_size251):
12506 
            _elem256 = Order()
12507 
            _elem256.read(iprot)
12508 
            self.success.append(_elem256)
4910 phani.kuma 12509 
          iprot.readListEnd()
12510 
        else:
12511 
          iprot.skip(ftype)
12512 
      else:
12513 
        iprot.skip(ftype)
12514 
      iprot.readFieldEnd()
12515 
    iprot.readStructEnd()
12516 
 
12517 
  def write(self, oprot):
12518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12520 
      return
12521 
    oprot.writeStructBegin('getRTOrders_result')
12522 
    if self.success is not None:
12523 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12524 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12525 
      for iter257 in self.success:
12526 
        iter257.write(oprot)
4910 phani.kuma 12527 
      oprot.writeListEnd()
12528 
      oprot.writeFieldEnd()
12529 
    oprot.writeFieldStop()
12530 
    oprot.writeStructEnd()
12531 
 
12532 
  def validate(self):
12533 
    return
12534 
 
12535 
 
12536 
  def __repr__(self):
12537 
    L = ['%s=%r' % (key, value)
12538 
      for key, value in self.__dict__.iteritems()]
12539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12540 
 
12541 
  def __eq__(self, other):
12542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12543 
 
12544 
  def __ne__(self, other):
12545 
    return not (self == other)
12546 
 
3064 chandransh 12547 
class updateNonDeliveryReason_args:
1627 ankur.sing 12548 
  """
12549 
  Attributes:
3064 chandransh 12550 
   - providerId
12551 
   - undeliveredOrders
1627 ankur.sing 12552 
  """
12553 
 
12554 
  thrift_spec = (
3064 chandransh 12555 
    None, # 0
12556 
    (1, TType.I64, 'providerId', None, None, ), # 1
12557 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 12558 
  )
12559 
 
3064 chandransh 12560 
  def __init__(self, providerId=None, undeliveredOrders=None,):
12561 
    self.providerId = providerId
12562 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 12563 
 
12564 
  def read(self, iprot):
12565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12567 
      return
12568 
    iprot.readStructBegin()
12569 
    while True:
12570 
      (fname, ftype, fid) = iprot.readFieldBegin()
12571 
      if ftype == TType.STOP:
12572 
        break
3064 chandransh 12573 
      if fid == 1:
1627 ankur.sing 12574 
        if ftype == TType.I64:
3064 chandransh 12575 
          self.providerId = iprot.readI64();
1627 ankur.sing 12576 
        else:
12577 
          iprot.skip(ftype)
3064 chandransh 12578 
      elif fid == 2:
12579 
        if ftype == TType.MAP:
12580 
          self.undeliveredOrders = {}
5031 varun.gupt 12581 
          (_ktype259, _vtype260, _size258 ) = iprot.readMapBegin()
12582 
          for _i262 in xrange(_size258):
12583 
            _key263 = iprot.readString();
12584 
            _val264 = iprot.readString();
12585 
            self.undeliveredOrders[_key263] = _val264
3064 chandransh 12586 
          iprot.readMapEnd()
12587 
        else:
12588 
          iprot.skip(ftype)
1627 ankur.sing 12589 
      else:
12590 
        iprot.skip(ftype)
12591 
      iprot.readFieldEnd()
12592 
    iprot.readStructEnd()
12593 
 
12594 
  def write(self, oprot):
12595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12597 
      return
3064 chandransh 12598 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 12599 
    if self.providerId is not None:
3064 chandransh 12600 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12601 
      oprot.writeI64(self.providerId)
1627 ankur.sing 12602 
      oprot.writeFieldEnd()
3431 rajveer 12603 
    if self.undeliveredOrders is not None:
3064 chandransh 12604 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
12605 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
5031 varun.gupt 12606 
      for kiter265,viter266 in self.undeliveredOrders.items():
12607 
        oprot.writeString(kiter265)
12608 
        oprot.writeString(viter266)
3064 chandransh 12609 
      oprot.writeMapEnd()
12610 
      oprot.writeFieldEnd()
1627 ankur.sing 12611 
    oprot.writeFieldStop()
12612 
    oprot.writeStructEnd()
12613 
 
3431 rajveer 12614 
  def validate(self):
12615 
    return
12616 
 
12617 
 
1627 ankur.sing 12618 
  def __repr__(self):
12619 
    L = ['%s=%r' % (key, value)
12620 
      for key, value in self.__dict__.iteritems()]
12621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12622 
 
12623 
  def __eq__(self, other):
12624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12625 
 
12626 
  def __ne__(self, other):
12627 
    return not (self == other)
12628 
 
3064 chandransh 12629 
class updateNonDeliveryReason_result:
1627 ankur.sing 12630 
  """
12631 
  Attributes:
3064 chandransh 12632 
   - ex
1627 ankur.sing 12633 
  """
12634 
 
12635 
  thrift_spec = (
4910 phani.kuma 12636 
    None, # 0
3064 chandransh 12637 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12638 
  )
12639 
 
4910 phani.kuma 12640 
  def __init__(self, ex=None,):
3064 chandransh 12641 
    self.ex = ex
1627 ankur.sing 12642 
 
12643 
  def read(self, iprot):
12644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12646 
      return
12647 
    iprot.readStructBegin()
12648 
    while True:
12649 
      (fname, ftype, fid) = iprot.readFieldBegin()
12650 
      if ftype == TType.STOP:
12651 
        break
4910 phani.kuma 12652 
      if fid == 1:
12653 
        if ftype == TType.STRUCT:
12654 
          self.ex = TransactionServiceException()
12655 
          self.ex.read(iprot)
12656 
        else:
12657 
          iprot.skip(ftype)
12658 
      else:
12659 
        iprot.skip(ftype)
12660 
      iprot.readFieldEnd()
12661 
    iprot.readStructEnd()
12662 
 
12663 
  def write(self, oprot):
12664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12666 
      return
12667 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
12668 
    if self.ex is not None:
12669 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12670 
      self.ex.write(oprot)
12671 
      oprot.writeFieldEnd()
12672 
    oprot.writeFieldStop()
12673 
    oprot.writeStructEnd()
12674 
 
12675 
  def validate(self):
12676 
    return
12677 
 
12678 
 
12679 
  def __repr__(self):
12680 
    L = ['%s=%r' % (key, value)
12681 
      for key, value in self.__dict__.iteritems()]
12682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12683 
 
12684 
  def __eq__(self, other):
12685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12686 
 
12687 
  def __ne__(self, other):
12688 
    return not (self == other)
12689 
 
12690 
class getNonDeliveredOrdersbyCourier_args:
12691 
  """
12692 
  Attributes:
12693 
   - providerId
12694 
  """
12695 
 
12696 
  thrift_spec = (
12697 
    None, # 0
12698 
    (1, TType.I64, 'providerId', None, None, ), # 1
12699 
  )
12700 
 
12701 
  def __init__(self, providerId=None,):
12702 
    self.providerId = providerId
12703 
 
12704 
  def read(self, iprot):
12705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12707 
      return
12708 
    iprot.readStructBegin()
12709 
    while True:
12710 
      (fname, ftype, fid) = iprot.readFieldBegin()
12711 
      if ftype == TType.STOP:
12712 
        break
12713 
      if fid == 1:
12714 
        if ftype == TType.I64:
12715 
          self.providerId = iprot.readI64();
12716 
        else:
12717 
          iprot.skip(ftype)
12718 
      else:
12719 
        iprot.skip(ftype)
12720 
      iprot.readFieldEnd()
12721 
    iprot.readStructEnd()
12722 
 
12723 
  def write(self, oprot):
12724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12726 
      return
12727 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
12728 
    if self.providerId is not None:
12729 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12730 
      oprot.writeI64(self.providerId)
12731 
      oprot.writeFieldEnd()
12732 
    oprot.writeFieldStop()
12733 
    oprot.writeStructEnd()
12734 
 
12735 
  def validate(self):
12736 
    return
12737 
 
12738 
 
12739 
  def __repr__(self):
12740 
    L = ['%s=%r' % (key, value)
12741 
      for key, value in self.__dict__.iteritems()]
12742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12743 
 
12744 
  def __eq__(self, other):
12745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12746 
 
12747 
  def __ne__(self, other):
12748 
    return not (self == other)
12749 
 
12750 
class getNonDeliveredOrdersbyCourier_result:
12751 
  """
12752 
  Attributes:
12753 
   - success
12754 
  """
12755 
 
12756 
  thrift_spec = (
12757 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12758 
  )
12759 
 
12760 
  def __init__(self, success=None,):
12761 
    self.success = success
12762 
 
12763 
  def read(self, iprot):
12764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12766 
      return
12767 
    iprot.readStructBegin()
12768 
    while True:
12769 
      (fname, ftype, fid) = iprot.readFieldBegin()
12770 
      if ftype == TType.STOP:
12771 
        break
4581 phani.kuma 12772 
      if fid == 0:
12773 
        if ftype == TType.LIST:
12774 
          self.success = []
5031 varun.gupt 12775 
          (_etype270, _size267) = iprot.readListBegin()
12776 
          for _i271 in xrange(_size267):
12777 
            _elem272 = Order()
12778 
            _elem272.read(iprot)
12779 
            self.success.append(_elem272)
4581 phani.kuma 12780 
          iprot.readListEnd()
12781 
        else:
12782 
          iprot.skip(ftype)
4910 phani.kuma 12783 
      else:
12784 
        iprot.skip(ftype)
12785 
      iprot.readFieldEnd()
12786 
    iprot.readStructEnd()
12787 
 
12788 
  def write(self, oprot):
12789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12791 
      return
12792 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
12793 
    if self.success is not None:
12794 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12795 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12796 
      for iter273 in self.success:
12797 
        iter273.write(oprot)
4910 phani.kuma 12798 
      oprot.writeListEnd()
12799 
      oprot.writeFieldEnd()
12800 
    oprot.writeFieldStop()
12801 
    oprot.writeStructEnd()
12802 
 
12803 
  def validate(self):
12804 
    return
12805 
 
12806 
 
12807 
  def __repr__(self):
12808 
    L = ['%s=%r' % (key, value)
12809 
      for key, value in self.__dict__.iteritems()]
12810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12811 
 
12812 
  def __eq__(self, other):
12813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12814 
 
12815 
  def __ne__(self, other):
12816 
    return not (self == other)
12817 
 
12818 
class markOrdersAsLocalConnected_args:
12819 
  """
12820 
  Attributes:
12821 
   - providerId
12822 
   - local_connected_orders
12823 
  """
12824 
 
12825 
  thrift_spec = (
12826 
    None, # 0
12827 
    (1, TType.I64, 'providerId', None, None, ), # 1
12828 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
12829 
  )
12830 
 
12831 
  def __init__(self, providerId=None, local_connected_orders=None,):
12832 
    self.providerId = providerId
12833 
    self.local_connected_orders = local_connected_orders
12834 
 
12835 
  def read(self, iprot):
12836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12838 
      return
12839 
    iprot.readStructBegin()
12840 
    while True:
12841 
      (fname, ftype, fid) = iprot.readFieldBegin()
12842 
      if ftype == TType.STOP:
12843 
        break
12844 
      if fid == 1:
12845 
        if ftype == TType.I64:
12846 
          self.providerId = iprot.readI64();
12847 
        else:
12848 
          iprot.skip(ftype)
12849 
      elif fid == 2:
12850 
        if ftype == TType.MAP:
12851 
          self.local_connected_orders = {}
5031 varun.gupt 12852 
          (_ktype275, _vtype276, _size274 ) = iprot.readMapBegin()
12853 
          for _i278 in xrange(_size274):
12854 
            _key279 = iprot.readString();
12855 
            _val280 = iprot.readString();
12856 
            self.local_connected_orders[_key279] = _val280
4910 phani.kuma 12857 
          iprot.readMapEnd()
12858 
        else:
12859 
          iprot.skip(ftype)
12860 
      else:
12861 
        iprot.skip(ftype)
12862 
      iprot.readFieldEnd()
12863 
    iprot.readStructEnd()
12864 
 
12865 
  def write(self, oprot):
12866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12868 
      return
12869 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
12870 
    if self.providerId is not None:
12871 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12872 
      oprot.writeI64(self.providerId)
12873 
      oprot.writeFieldEnd()
12874 
    if self.local_connected_orders is not None:
12875 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
12876 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
5031 varun.gupt 12877 
      for kiter281,viter282 in self.local_connected_orders.items():
12878 
        oprot.writeString(kiter281)
12879 
        oprot.writeString(viter282)
4910 phani.kuma 12880 
      oprot.writeMapEnd()
12881 
      oprot.writeFieldEnd()
12882 
    oprot.writeFieldStop()
12883 
    oprot.writeStructEnd()
12884 
 
12885 
  def validate(self):
12886 
    return
12887 
 
12888 
 
12889 
  def __repr__(self):
12890 
    L = ['%s=%r' % (key, value)
12891 
      for key, value in self.__dict__.iteritems()]
12892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12893 
 
12894 
  def __eq__(self, other):
12895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12896 
 
12897 
  def __ne__(self, other):
12898 
    return not (self == other)
12899 
 
12900 
class markOrdersAsLocalConnected_result:
12901 
  """
12902 
  Attributes:
12903 
   - ex
12904 
  """
12905 
 
12906 
  thrift_spec = (
12907 
    None, # 0
12908 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12909 
  )
12910 
 
12911 
  def __init__(self, ex=None,):
12912 
    self.ex = ex
12913 
 
12914 
  def read(self, iprot):
12915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12917 
      return
12918 
    iprot.readStructBegin()
12919 
    while True:
12920 
      (fname, ftype, fid) = iprot.readFieldBegin()
12921 
      if ftype == TType.STOP:
12922 
        break
12923 
      if fid == 1:
3064 chandransh 12924 
        if ftype == TType.STRUCT:
12925 
          self.ex = TransactionServiceException()
12926 
          self.ex.read(iprot)
1627 ankur.sing 12927 
        else:
12928 
          iprot.skip(ftype)
12929 
      else:
12930 
        iprot.skip(ftype)
12931 
      iprot.readFieldEnd()
12932 
    iprot.readStructEnd()
12933 
 
12934 
  def write(self, oprot):
12935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12937 
      return
4910 phani.kuma 12938 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
12939 
    if self.ex is not None:
12940 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12941 
      self.ex.write(oprot)
12942 
      oprot.writeFieldEnd()
12943 
    oprot.writeFieldStop()
12944 
    oprot.writeStructEnd()
12945 
 
12946 
  def validate(self):
12947 
    return
12948 
 
12949 
 
12950 
  def __repr__(self):
12951 
    L = ['%s=%r' % (key, value)
12952 
      for key, value in self.__dict__.iteritems()]
12953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12954 
 
12955 
  def __eq__(self, other):
12956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12957 
 
12958 
  def __ne__(self, other):
12959 
    return not (self == other)
12960 
 
12961 
class getOrdersNotLocalConnected_args:
12962 
  """
12963 
  Attributes:
12964 
   - providerId
12965 
  """
12966 
 
12967 
  thrift_spec = (
12968 
    None, # 0
12969 
    (1, TType.I64, 'providerId', None, None, ), # 1
12970 
  )
12971 
 
12972 
  def __init__(self, providerId=None,):
12973 
    self.providerId = providerId
12974 
 
12975 
  def read(self, iprot):
12976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12978 
      return
12979 
    iprot.readStructBegin()
12980 
    while True:
12981 
      (fname, ftype, fid) = iprot.readFieldBegin()
12982 
      if ftype == TType.STOP:
12983 
        break
12984 
      if fid == 1:
12985 
        if ftype == TType.I64:
12986 
          self.providerId = iprot.readI64();
12987 
        else:
12988 
          iprot.skip(ftype)
12989 
      else:
12990 
        iprot.skip(ftype)
12991 
      iprot.readFieldEnd()
12992 
    iprot.readStructEnd()
12993 
 
12994 
  def write(self, oprot):
12995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12997 
      return
12998 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
12999 
    if self.providerId is not None:
13000 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13001 
      oprot.writeI64(self.providerId)
13002 
      oprot.writeFieldEnd()
13003 
    oprot.writeFieldStop()
13004 
    oprot.writeStructEnd()
13005 
 
13006 
  def validate(self):
13007 
    return
13008 
 
13009 
 
13010 
  def __repr__(self):
13011 
    L = ['%s=%r' % (key, value)
13012 
      for key, value in self.__dict__.iteritems()]
13013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13014 
 
13015 
  def __eq__(self, other):
13016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13017 
 
13018 
  def __ne__(self, other):
13019 
    return not (self == other)
13020 
 
13021 
class getOrdersNotLocalConnected_result:
13022 
  """
13023 
  Attributes:
13024 
   - success
13025 
  """
13026 
 
13027 
  thrift_spec = (
13028 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13029 
  )
13030 
 
13031 
  def __init__(self, success=None,):
13032 
    self.success = success
13033 
 
13034 
  def read(self, iprot):
13035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13037 
      return
13038 
    iprot.readStructBegin()
13039 
    while True:
13040 
      (fname, ftype, fid) = iprot.readFieldBegin()
13041 
      if ftype == TType.STOP:
13042 
        break
13043 
      if fid == 0:
13044 
        if ftype == TType.LIST:
13045 
          self.success = []
5031 varun.gupt 13046 
          (_etype286, _size283) = iprot.readListBegin()
13047 
          for _i287 in xrange(_size283):
13048 
            _elem288 = Order()
13049 
            _elem288.read(iprot)
13050 
            self.success.append(_elem288)
4910 phani.kuma 13051 
          iprot.readListEnd()
13052 
        else:
13053 
          iprot.skip(ftype)
13054 
      else:
13055 
        iprot.skip(ftype)
13056 
      iprot.readFieldEnd()
13057 
    iprot.readStructEnd()
13058 
 
13059 
  def write(self, oprot):
13060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13062 
      return
13063 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 13064 
    if self.success is not None:
13065 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13066 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13067 
      for iter289 in self.success:
13068 
        iter289.write(oprot)
4581 phani.kuma 13069 
      oprot.writeListEnd()
13070 
      oprot.writeFieldEnd()
4910 phani.kuma 13071 
    oprot.writeFieldStop()
13072 
    oprot.writeStructEnd()
13073 
 
13074 
  def validate(self):
13075 
    return
13076 
 
13077 
 
13078 
  def __repr__(self):
13079 
    L = ['%s=%r' % (key, value)
13080 
      for key, value in self.__dict__.iteritems()]
13081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13082 
 
13083 
  def __eq__(self, other):
13084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13085 
 
13086 
  def __ne__(self, other):
13087 
    return not (self == other)
13088 
 
13089 
class markOrdersAsDestinationCityReached_args:
13090 
  """
13091 
  Attributes:
13092 
   - providerId
13093 
   - destination_city_reached_orders
13094 
  """
13095 
 
13096 
  thrift_spec = (
13097 
    None, # 0
13098 
    (1, TType.I64, 'providerId', None, None, ), # 1
13099 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13100 
  )
13101 
 
13102 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
13103 
    self.providerId = providerId
13104 
    self.destination_city_reached_orders = destination_city_reached_orders
13105 
 
13106 
  def read(self, iprot):
13107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13109 
      return
13110 
    iprot.readStructBegin()
13111 
    while True:
13112 
      (fname, ftype, fid) = iprot.readFieldBegin()
13113 
      if ftype == TType.STOP:
13114 
        break
13115 
      if fid == 1:
13116 
        if ftype == TType.I64:
13117 
          self.providerId = iprot.readI64();
13118 
        else:
13119 
          iprot.skip(ftype)
13120 
      elif fid == 2:
13121 
        if ftype == TType.MAP:
13122 
          self.destination_city_reached_orders = {}
5031 varun.gupt 13123 
          (_ktype291, _vtype292, _size290 ) = iprot.readMapBegin()
13124 
          for _i294 in xrange(_size290):
13125 
            _key295 = iprot.readString();
13126 
            _val296 = iprot.readString();
13127 
            self.destination_city_reached_orders[_key295] = _val296
4910 phani.kuma 13128 
          iprot.readMapEnd()
13129 
        else:
13130 
          iprot.skip(ftype)
13131 
      else:
13132 
        iprot.skip(ftype)
13133 
      iprot.readFieldEnd()
13134 
    iprot.readStructEnd()
13135 
 
13136 
  def write(self, oprot):
13137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13139 
      return
13140 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
13141 
    if self.providerId is not None:
13142 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13143 
      oprot.writeI64(self.providerId)
13144 
      oprot.writeFieldEnd()
13145 
    if self.destination_city_reached_orders is not None:
13146 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
13147 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
5031 varun.gupt 13148 
      for kiter297,viter298 in self.destination_city_reached_orders.items():
13149 
        oprot.writeString(kiter297)
13150 
        oprot.writeString(viter298)
4910 phani.kuma 13151 
      oprot.writeMapEnd()
13152 
      oprot.writeFieldEnd()
13153 
    oprot.writeFieldStop()
13154 
    oprot.writeStructEnd()
13155 
 
13156 
  def validate(self):
13157 
    return
13158 
 
13159 
 
13160 
  def __repr__(self):
13161 
    L = ['%s=%r' % (key, value)
13162 
      for key, value in self.__dict__.iteritems()]
13163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13164 
 
13165 
  def __eq__(self, other):
13166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13167 
 
13168 
  def __ne__(self, other):
13169 
    return not (self == other)
13170 
 
13171 
class markOrdersAsDestinationCityReached_result:
13172 
  """
13173 
  Attributes:
13174 
   - ex
13175 
  """
13176 
 
13177 
  thrift_spec = (
13178 
    None, # 0
13179 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13180 
  )
13181 
 
13182 
  def __init__(self, ex=None,):
13183 
    self.ex = ex
13184 
 
13185 
  def read(self, iprot):
13186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13188 
      return
13189 
    iprot.readStructBegin()
13190 
    while True:
13191 
      (fname, ftype, fid) = iprot.readFieldBegin()
13192 
      if ftype == TType.STOP:
13193 
        break
13194 
      if fid == 1:
13195 
        if ftype == TType.STRUCT:
13196 
          self.ex = TransactionServiceException()
13197 
          self.ex.read(iprot)
13198 
        else:
13199 
          iprot.skip(ftype)
13200 
      else:
13201 
        iprot.skip(ftype)
13202 
      iprot.readFieldEnd()
13203 
    iprot.readStructEnd()
13204 
 
13205 
  def write(self, oprot):
13206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13208 
      return
13209 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 13210 
    if self.ex is not None:
3064 chandransh 13211 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13212 
      self.ex.write(oprot)
1627 ankur.sing 13213 
      oprot.writeFieldEnd()
13214 
    oprot.writeFieldStop()
13215 
    oprot.writeStructEnd()
13216 
 
3431 rajveer 13217 
  def validate(self):
13218 
    return
13219 
 
13220 
 
1627 ankur.sing 13221 
  def __repr__(self):
13222 
    L = ['%s=%r' % (key, value)
13223 
      for key, value in self.__dict__.iteritems()]
13224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13225 
 
13226 
  def __eq__(self, other):
13227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13228 
 
13229 
  def __ne__(self, other):
13230 
    return not (self == other)
13231 
 
4910 phani.kuma 13232 
class markOrdersAsFirstDeliveryAttempted_args:
13233 
  """
13234 
  Attributes:
13235 
   - providerId
13236 
   - first_atdl_orders
13237 
  """
13238 
 
13239 
  thrift_spec = (
13240 
    None, # 0
13241 
    (1, TType.I64, 'providerId', None, None, ), # 1
13242 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13243 
  )
13244 
 
13245 
  def __init__(self, providerId=None, first_atdl_orders=None,):
13246 
    self.providerId = providerId
13247 
    self.first_atdl_orders = first_atdl_orders
13248 
 
13249 
  def read(self, iprot):
13250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13252 
      return
13253 
    iprot.readStructBegin()
13254 
    while True:
13255 
      (fname, ftype, fid) = iprot.readFieldBegin()
13256 
      if ftype == TType.STOP:
13257 
        break
13258 
      if fid == 1:
13259 
        if ftype == TType.I64:
13260 
          self.providerId = iprot.readI64();
13261 
        else:
13262 
          iprot.skip(ftype)
13263 
      elif fid == 2:
13264 
        if ftype == TType.MAP:
13265 
          self.first_atdl_orders = {}
5031 varun.gupt 13266 
          (_ktype300, _vtype301, _size299 ) = iprot.readMapBegin()
13267 
          for _i303 in xrange(_size299):
13268 
            _key304 = iprot.readString();
13269 
            _val305 = iprot.readString();
13270 
            self.first_atdl_orders[_key304] = _val305
4910 phani.kuma 13271 
          iprot.readMapEnd()
13272 
        else:
13273 
          iprot.skip(ftype)
13274 
      else:
13275 
        iprot.skip(ftype)
13276 
      iprot.readFieldEnd()
13277 
    iprot.readStructEnd()
13278 
 
13279 
  def write(self, oprot):
13280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13282 
      return
13283 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
13284 
    if self.providerId is not None:
13285 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13286 
      oprot.writeI64(self.providerId)
13287 
      oprot.writeFieldEnd()
13288 
    if self.first_atdl_orders is not None:
13289 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
13290 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
5031 varun.gupt 13291 
      for kiter306,viter307 in self.first_atdl_orders.items():
13292 
        oprot.writeString(kiter306)
13293 
        oprot.writeString(viter307)
4910 phani.kuma 13294 
      oprot.writeMapEnd()
13295 
      oprot.writeFieldEnd()
13296 
    oprot.writeFieldStop()
13297 
    oprot.writeStructEnd()
13298 
 
13299 
  def validate(self):
13300 
    return
13301 
 
13302 
 
13303 
  def __repr__(self):
13304 
    L = ['%s=%r' % (key, value)
13305 
      for key, value in self.__dict__.iteritems()]
13306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13307 
 
13308 
  def __eq__(self, other):
13309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13310 
 
13311 
  def __ne__(self, other):
13312 
    return not (self == other)
13313 
 
13314 
class markOrdersAsFirstDeliveryAttempted_result:
13315 
  """
13316 
  Attributes:
13317 
   - ex
13318 
  """
13319 
 
13320 
  thrift_spec = (
13321 
    None, # 0
13322 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13323 
  )
13324 
 
13325 
  def __init__(self, ex=None,):
13326 
    self.ex = ex
13327 
 
13328 
  def read(self, iprot):
13329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13331 
      return
13332 
    iprot.readStructBegin()
13333 
    while True:
13334 
      (fname, ftype, fid) = iprot.readFieldBegin()
13335 
      if ftype == TType.STOP:
13336 
        break
13337 
      if fid == 1:
13338 
        if ftype == TType.STRUCT:
13339 
          self.ex = TransactionServiceException()
13340 
          self.ex.read(iprot)
13341 
        else:
13342 
          iprot.skip(ftype)
13343 
      else:
13344 
        iprot.skip(ftype)
13345 
      iprot.readFieldEnd()
13346 
    iprot.readStructEnd()
13347 
 
13348 
  def write(self, oprot):
13349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13351 
      return
13352 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
13353 
    if self.ex is not None:
13354 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13355 
      self.ex.write(oprot)
13356 
      oprot.writeFieldEnd()
13357 
    oprot.writeFieldStop()
13358 
    oprot.writeStructEnd()
13359 
 
13360 
  def validate(self):
13361 
    return
13362 
 
13363 
 
13364 
  def __repr__(self):
13365 
    L = ['%s=%r' % (key, value)
13366 
      for key, value in self.__dict__.iteritems()]
13367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13368 
 
13369 
  def __eq__(self, other):
13370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13371 
 
13372 
  def __ne__(self, other):
13373 
    return not (self == other)
13374 
 
3064 chandransh 13375 
class getUndeliveredOrders_args:
1886 ankur.sing 13376 
  """
13377 
  Attributes:
3064 chandransh 13378 
   - providerId
13379 
   - warehouseId
1886 ankur.sing 13380 
  """
1627 ankur.sing 13381 
 
1886 ankur.sing 13382 
  thrift_spec = (
13383 
    None, # 0
3064 chandransh 13384 
    (1, TType.I64, 'providerId', None, None, ), # 1
13385 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 13386 
  )
13387 
 
3064 chandransh 13388 
  def __init__(self, providerId=None, warehouseId=None,):
13389 
    self.providerId = providerId
13390 
    self.warehouseId = warehouseId
1886 ankur.sing 13391 
 
13392 
  def read(self, iprot):
13393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13395 
      return
13396 
    iprot.readStructBegin()
13397 
    while True:
13398 
      (fname, ftype, fid) = iprot.readFieldBegin()
13399 
      if ftype == TType.STOP:
13400 
        break
13401 
      if fid == 1:
13402 
        if ftype == TType.I64:
3064 chandransh 13403 
          self.providerId = iprot.readI64();
1886 ankur.sing 13404 
        else:
13405 
          iprot.skip(ftype)
3064 chandransh 13406 
      elif fid == 2:
13407 
        if ftype == TType.I64:
13408 
          self.warehouseId = iprot.readI64();
13409 
        else:
13410 
          iprot.skip(ftype)
1886 ankur.sing 13411 
      else:
13412 
        iprot.skip(ftype)
13413 
      iprot.readFieldEnd()
13414 
    iprot.readStructEnd()
13415 
 
13416 
  def write(self, oprot):
13417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13419 
      return
3064 chandransh 13420 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 13421 
    if self.providerId is not None:
3064 chandransh 13422 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13423 
      oprot.writeI64(self.providerId)
1886 ankur.sing 13424 
      oprot.writeFieldEnd()
3431 rajveer 13425 
    if self.warehouseId is not None:
3064 chandransh 13426 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13427 
      oprot.writeI64(self.warehouseId)
13428 
      oprot.writeFieldEnd()
1886 ankur.sing 13429 
    oprot.writeFieldStop()
13430 
    oprot.writeStructEnd()
13431 
 
3431 rajveer 13432 
  def validate(self):
13433 
    return
13434 
 
13435 
 
1886 ankur.sing 13436 
  def __repr__(self):
13437 
    L = ['%s=%r' % (key, value)
13438 
      for key, value in self.__dict__.iteritems()]
13439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13440 
 
13441 
  def __eq__(self, other):
13442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13443 
 
13444 
  def __ne__(self, other):
13445 
    return not (self == other)
13446 
 
3064 chandransh 13447 
class getUndeliveredOrders_result:
1886 ankur.sing 13448 
  """
13449 
  Attributes:
13450 
   - success
13451 
  """
13452 
 
13453 
  thrift_spec = (
13454 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13455 
  )
13456 
 
13457 
  def __init__(self, success=None,):
13458 
    self.success = success
13459 
 
13460 
  def read(self, iprot):
13461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13463 
      return
13464 
    iprot.readStructBegin()
13465 
    while True:
13466 
      (fname, ftype, fid) = iprot.readFieldBegin()
13467 
      if ftype == TType.STOP:
13468 
        break
13469 
      if fid == 0:
13470 
        if ftype == TType.LIST:
13471 
          self.success = []
5031 varun.gupt 13472 
          (_etype311, _size308) = iprot.readListBegin()
13473 
          for _i312 in xrange(_size308):
13474 
            _elem313 = Order()
13475 
            _elem313.read(iprot)
13476 
            self.success.append(_elem313)
1886 ankur.sing 13477 
          iprot.readListEnd()
13478 
        else:
13479 
          iprot.skip(ftype)
13480 
      else:
13481 
        iprot.skip(ftype)
13482 
      iprot.readFieldEnd()
13483 
    iprot.readStructEnd()
13484 
 
13485 
  def write(self, oprot):
13486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13488 
      return
3064 chandransh 13489 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 13490 
    if self.success is not None:
1886 ankur.sing 13491 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13492 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13493 
      for iter314 in self.success:
13494 
        iter314.write(oprot)
1886 ankur.sing 13495 
      oprot.writeListEnd()
13496 
      oprot.writeFieldEnd()
13497 
    oprot.writeFieldStop()
13498 
    oprot.writeStructEnd()
13499 
 
3431 rajveer 13500 
  def validate(self):
13501 
    return
13502 
 
13503 
 
1886 ankur.sing 13504 
  def __repr__(self):
13505 
    L = ['%s=%r' % (key, value)
13506 
      for key, value in self.__dict__.iteritems()]
13507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13508 
 
13509 
  def __eq__(self, other):
13510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13511 
 
13512 
  def __ne__(self, other):
13513 
    return not (self == other)
13514 
 
4783 phani.kuma 13515 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
13516 
 
13517 
  thrift_spec = (
13518 
  )
13519 
 
13520 
  def read(self, iprot):
13521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13523 
      return
13524 
    iprot.readStructBegin()
13525 
    while True:
13526 
      (fname, ftype, fid) = iprot.readFieldBegin()
13527 
      if ftype == TType.STOP:
13528 
        break
13529 
      else:
13530 
        iprot.skip(ftype)
13531 
      iprot.readFieldEnd()
13532 
    iprot.readStructEnd()
13533 
 
13534 
  def write(self, oprot):
13535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13537 
      return
13538 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
13539 
    oprot.writeFieldStop()
13540 
    oprot.writeStructEnd()
13541 
 
13542 
  def validate(self):
13543 
    return
13544 
 
13545 
 
13546 
  def __repr__(self):
13547 
    L = ['%s=%r' % (key, value)
13548 
      for key, value in self.__dict__.iteritems()]
13549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13550 
 
13551 
  def __eq__(self, other):
13552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13553 
 
13554 
  def __ne__(self, other):
13555 
    return not (self == other)
13556 
 
13557 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
13558 
  """
13559 
  Attributes:
13560 
   - success
13561 
  """
13562 
 
13563 
  thrift_spec = (
13564 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13565 
  )
13566 
 
13567 
  def __init__(self, success=None,):
13568 
    self.success = success
13569 
 
13570 
  def read(self, iprot):
13571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13573 
      return
13574 
    iprot.readStructBegin()
13575 
    while True:
13576 
      (fname, ftype, fid) = iprot.readFieldBegin()
13577 
      if ftype == TType.STOP:
13578 
        break
13579 
      if fid == 0:
13580 
        if ftype == TType.LIST:
13581 
          self.success = []
5031 varun.gupt 13582 
          (_etype318, _size315) = iprot.readListBegin()
13583 
          for _i319 in xrange(_size315):
13584 
            _elem320 = Order()
13585 
            _elem320.read(iprot)
13586 
            self.success.append(_elem320)
4783 phani.kuma 13587 
          iprot.readListEnd()
13588 
        else:
13589 
          iprot.skip(ftype)
13590 
      else:
13591 
        iprot.skip(ftype)
13592 
      iprot.readFieldEnd()
13593 
    iprot.readStructEnd()
13594 
 
13595 
  def write(self, oprot):
13596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13598 
      return
13599 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
13600 
    if self.success is not None:
13601 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13602 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13603 
      for iter321 in self.success:
13604 
        iter321.write(oprot)
4783 phani.kuma 13605 
      oprot.writeListEnd()
13606 
      oprot.writeFieldEnd()
13607 
    oprot.writeFieldStop()
13608 
    oprot.writeStructEnd()
13609 
 
13610 
  def validate(self):
13611 
    return
13612 
 
13613 
 
13614 
  def __repr__(self):
13615 
    L = ['%s=%r' % (key, value)
13616 
      for key, value in self.__dict__.iteritems()]
13617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13618 
 
13619 
  def __eq__(self, other):
13620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13621 
 
13622 
  def __ne__(self, other):
13623 
    return not (self == other)
13624 
 
2536 chandransh 13625 
class toggleDOAFlag_args:
13626 
  """
13627 
  Attributes:
13628 
   - orderId
13629 
  """
1886 ankur.sing 13630 
 
2536 chandransh 13631 
  thrift_spec = (
13632 
    None, # 0
13633 
    (1, TType.I64, 'orderId', None, None, ), # 1
13634 
  )
13635 
 
13636 
  def __init__(self, orderId=None,):
13637 
    self.orderId = orderId
13638 
 
13639 
  def read(self, iprot):
13640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13642 
      return
13643 
    iprot.readStructBegin()
13644 
    while True:
13645 
      (fname, ftype, fid) = iprot.readFieldBegin()
13646 
      if ftype == TType.STOP:
13647 
        break
13648 
      if fid == 1:
13649 
        if ftype == TType.I64:
13650 
          self.orderId = iprot.readI64();
13651 
        else:
13652 
          iprot.skip(ftype)
13653 
      else:
13654 
        iprot.skip(ftype)
13655 
      iprot.readFieldEnd()
13656 
    iprot.readStructEnd()
13657 
 
13658 
  def write(self, oprot):
13659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13661 
      return
13662 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 13663 
    if self.orderId is not None:
2536 chandransh 13664 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13665 
      oprot.writeI64(self.orderId)
13666 
      oprot.writeFieldEnd()
13667 
    oprot.writeFieldStop()
13668 
    oprot.writeStructEnd()
13669 
 
3431 rajveer 13670 
  def validate(self):
13671 
    return
13672 
 
13673 
 
2536 chandransh 13674 
  def __repr__(self):
13675 
    L = ['%s=%r' % (key, value)
13676 
      for key, value in self.__dict__.iteritems()]
13677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13678 
 
13679 
  def __eq__(self, other):
13680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13681 
 
13682 
  def __ne__(self, other):
13683 
    return not (self == other)
13684 
 
13685 
class toggleDOAFlag_result:
13686 
  """
13687 
  Attributes:
13688 
   - success
13689 
   - ex
13690 
  """
13691 
 
13692 
  thrift_spec = (
13693 
    (0, TType.BOOL, 'success', None, None, ), # 0
13694 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13695 
  )
13696 
 
13697 
  def __init__(self, success=None, ex=None,):
13698 
    self.success = success
13699 
    self.ex = ex
13700 
 
13701 
  def read(self, iprot):
13702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13704 
      return
13705 
    iprot.readStructBegin()
13706 
    while True:
13707 
      (fname, ftype, fid) = iprot.readFieldBegin()
13708 
      if ftype == TType.STOP:
13709 
        break
13710 
      if fid == 0:
13711 
        if ftype == TType.BOOL:
13712 
          self.success = iprot.readBool();
13713 
        else:
13714 
          iprot.skip(ftype)
13715 
      elif fid == 1:
13716 
        if ftype == TType.STRUCT:
13717 
          self.ex = TransactionServiceException()
13718 
          self.ex.read(iprot)
13719 
        else:
13720 
          iprot.skip(ftype)
13721 
      else:
13722 
        iprot.skip(ftype)
13723 
      iprot.readFieldEnd()
13724 
    iprot.readStructEnd()
13725 
 
13726 
  def write(self, oprot):
13727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13729 
      return
13730 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 13731 
    if self.success is not None:
2536 chandransh 13732 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13733 
      oprot.writeBool(self.success)
13734 
      oprot.writeFieldEnd()
3431 rajveer 13735 
    if self.ex is not None:
2536 chandransh 13736 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13737 
      self.ex.write(oprot)
13738 
      oprot.writeFieldEnd()
13739 
    oprot.writeFieldStop()
13740 
    oprot.writeStructEnd()
13741 
 
3431 rajveer 13742 
  def validate(self):
13743 
    return
13744 
 
13745 
 
2536 chandransh 13746 
  def __repr__(self):
13747 
    L = ['%s=%r' % (key, value)
13748 
      for key, value in self.__dict__.iteritems()]
13749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13750 
 
13751 
  def __eq__(self, other):
13752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13753 
 
13754 
  def __ne__(self, other):
13755 
    return not (self == other)
13756 
 
4712 rajveer 13757 
class markOrderAsDelivered_args:
13758 
  """
13759 
  Attributes:
13760 
   - orderId
13761 
   - deliveryTimestamp
13762 
   - receiver
13763 
  """
13764 
 
13765 
  thrift_spec = None
13766 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
13767 
    self.orderId = orderId
13768 
    self.deliveryTimestamp = deliveryTimestamp
13769 
    self.receiver = receiver
13770 
 
13771 
  def read(self, iprot):
13772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13774 
      return
13775 
    iprot.readStructBegin()
13776 
    while True:
13777 
      (fname, ftype, fid) = iprot.readFieldBegin()
13778 
      if ftype == TType.STOP:
13779 
        break
13780 
      if fid == 1:
13781 
        if ftype == TType.I64:
13782 
          self.orderId = iprot.readI64();
13783 
        else:
13784 
          iprot.skip(ftype)
13785 
      elif fid == 2:
13786 
        if ftype == TType.I64:
13787 
          self.deliveryTimestamp = iprot.readI64();
13788 
        else:
13789 
          iprot.skip(ftype)
13790 
      elif fid == -1:
13791 
        if ftype == TType.STRING:
13792 
          self.receiver = iprot.readString();
13793 
        else:
13794 
          iprot.skip(ftype)
13795 
      else:
13796 
        iprot.skip(ftype)
13797 
      iprot.readFieldEnd()
13798 
    iprot.readStructEnd()
13799 
 
13800 
  def write(self, oprot):
13801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13803 
      return
13804 
    oprot.writeStructBegin('markOrderAsDelivered_args')
13805 
    if self.receiver is not None:
13806 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
13807 
      oprot.writeString(self.receiver)
13808 
      oprot.writeFieldEnd()
13809 
    if self.orderId is not None:
13810 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13811 
      oprot.writeI64(self.orderId)
13812 
      oprot.writeFieldEnd()
13813 
    if self.deliveryTimestamp is not None:
13814 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
13815 
      oprot.writeI64(self.deliveryTimestamp)
13816 
      oprot.writeFieldEnd()
13817 
    oprot.writeFieldStop()
13818 
    oprot.writeStructEnd()
13819 
 
13820 
  def validate(self):
13821 
    return
13822 
 
13823 
 
13824 
  def __repr__(self):
13825 
    L = ['%s=%r' % (key, value)
13826 
      for key, value in self.__dict__.iteritems()]
13827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13828 
 
13829 
  def __eq__(self, other):
13830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13831 
 
13832 
  def __ne__(self, other):
13833 
    return not (self == other)
13834 
 
13835 
class markOrderAsDelivered_result:
13836 
  """
13837 
  Attributes:
13838 
   - ex
13839 
  """
13840 
 
13841 
  thrift_spec = (
13842 
    None, # 0
13843 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13844 
  )
13845 
 
13846 
  def __init__(self, ex=None,):
13847 
    self.ex = ex
13848 
 
13849 
  def read(self, iprot):
13850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13852 
      return
13853 
    iprot.readStructBegin()
13854 
    while True:
13855 
      (fname, ftype, fid) = iprot.readFieldBegin()
13856 
      if ftype == TType.STOP:
13857 
        break
13858 
      if fid == 1:
13859 
        if ftype == TType.STRUCT:
13860 
          self.ex = TransactionServiceException()
13861 
          self.ex.read(iprot)
13862 
        else:
13863 
          iprot.skip(ftype)
13864 
      else:
13865 
        iprot.skip(ftype)
13866 
      iprot.readFieldEnd()
13867 
    iprot.readStructEnd()
13868 
 
13869 
  def write(self, oprot):
13870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13872 
      return
13873 
    oprot.writeStructBegin('markOrderAsDelivered_result')
13874 
    if self.ex is not None:
13875 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13876 
      self.ex.write(oprot)
13877 
      oprot.writeFieldEnd()
13878 
    oprot.writeFieldStop()
13879 
    oprot.writeStructEnd()
13880 
 
13881 
  def validate(self):
13882 
    return
13883 
 
13884 
 
13885 
  def __repr__(self):
13886 
    L = ['%s=%r' % (key, value)
13887 
      for key, value in self.__dict__.iteritems()]
13888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13889 
 
13890 
  def __eq__(self, other):
13891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13892 
 
13893 
  def __ne__(self, other):
13894 
    return not (self == other)
13895 
 
4454 rajveer 13896 
class markOrderDoaRequestReceived_args:
13897 
  """
13898 
  Attributes:
13899 
   - orderId
13900 
  """
13901 
 
13902 
  thrift_spec = (
13903 
    None, # 0
13904 
    (1, TType.I64, 'orderId', None, None, ), # 1
13905 
  )
13906 
 
13907 
  def __init__(self, orderId=None,):
13908 
    self.orderId = orderId
13909 
 
13910 
  def read(self, iprot):
13911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13913 
      return
13914 
    iprot.readStructBegin()
13915 
    while True:
13916 
      (fname, ftype, fid) = iprot.readFieldBegin()
13917 
      if ftype == TType.STOP:
13918 
        break
13919 
      if fid == 1:
13920 
        if ftype == TType.I64:
13921 
          self.orderId = iprot.readI64();
13922 
        else:
13923 
          iprot.skip(ftype)
13924 
      else:
13925 
        iprot.skip(ftype)
13926 
      iprot.readFieldEnd()
13927 
    iprot.readStructEnd()
13928 
 
13929 
  def write(self, oprot):
13930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13932 
      return
13933 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
13934 
    if self.orderId is not None:
13935 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13936 
      oprot.writeI64(self.orderId)
13937 
      oprot.writeFieldEnd()
13938 
    oprot.writeFieldStop()
13939 
    oprot.writeStructEnd()
13940 
 
13941 
  def validate(self):
13942 
    return
13943 
 
13944 
 
13945 
  def __repr__(self):
13946 
    L = ['%s=%r' % (key, value)
13947 
      for key, value in self.__dict__.iteritems()]
13948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13949 
 
13950 
  def __eq__(self, other):
13951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13952 
 
13953 
  def __ne__(self, other):
13954 
    return not (self == other)
13955 
 
13956 
class markOrderDoaRequestReceived_result:
13957 
  """
13958 
  Attributes:
13959 
   - success
13960 
   - ex
13961 
  """
13962 
 
13963 
  thrift_spec = (
13964 
    (0, TType.BOOL, 'success', None, None, ), # 0
13965 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13966 
  )
13967 
 
13968 
  def __init__(self, success=None, ex=None,):
13969 
    self.success = success
13970 
    self.ex = ex
13971 
 
13972 
  def read(self, iprot):
13973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13975 
      return
13976 
    iprot.readStructBegin()
13977 
    while True:
13978 
      (fname, ftype, fid) = iprot.readFieldBegin()
13979 
      if ftype == TType.STOP:
13980 
        break
13981 
      if fid == 0:
13982 
        if ftype == TType.BOOL:
13983 
          self.success = iprot.readBool();
13984 
        else:
13985 
          iprot.skip(ftype)
13986 
      elif fid == 1:
13987 
        if ftype == TType.STRUCT:
13988 
          self.ex = TransactionServiceException()
13989 
          self.ex.read(iprot)
13990 
        else:
13991 
          iprot.skip(ftype)
13992 
      else:
13993 
        iprot.skip(ftype)
13994 
      iprot.readFieldEnd()
13995 
    iprot.readStructEnd()
13996 
 
13997 
  def write(self, oprot):
13998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14000 
      return
14001 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
14002 
    if self.success is not None:
14003 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14004 
      oprot.writeBool(self.success)
14005 
      oprot.writeFieldEnd()
14006 
    if self.ex is not None:
14007 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14008 
      self.ex.write(oprot)
14009 
      oprot.writeFieldEnd()
14010 
    oprot.writeFieldStop()
14011 
    oprot.writeStructEnd()
14012 
 
14013 
  def validate(self):
14014 
    return
14015 
 
14016 
 
14017 
  def __repr__(self):
14018 
    L = ['%s=%r' % (key, value)
14019 
      for key, value in self.__dict__.iteritems()]
14020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14021 
 
14022 
  def __eq__(self, other):
14023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14024 
 
14025 
  def __ne__(self, other):
14026 
    return not (self == other)
14027 
 
14028 
class markOrderDoaRequestAuthorized_args:
14029 
  """
14030 
  Attributes:
14031 
   - orderId
14032 
   - isAuthorized
14033 
  """
14034 
 
14035 
  thrift_spec = (
14036 
    None, # 0
14037 
    (1, TType.I64, 'orderId', None, None, ), # 1
14038 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14039 
  )
14040 
 
14041 
  def __init__(self, orderId=None, isAuthorized=None,):
14042 
    self.orderId = orderId
14043 
    self.isAuthorized = isAuthorized
14044 
 
14045 
  def read(self, iprot):
14046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14048 
      return
14049 
    iprot.readStructBegin()
14050 
    while True:
14051 
      (fname, ftype, fid) = iprot.readFieldBegin()
14052 
      if ftype == TType.STOP:
14053 
        break
14054 
      if fid == 1:
14055 
        if ftype == TType.I64:
14056 
          self.orderId = iprot.readI64();
14057 
        else:
14058 
          iprot.skip(ftype)
14059 
      elif fid == 2:
14060 
        if ftype == TType.BOOL:
14061 
          self.isAuthorized = iprot.readBool();
14062 
        else:
14063 
          iprot.skip(ftype)
14064 
      else:
14065 
        iprot.skip(ftype)
14066 
      iprot.readFieldEnd()
14067 
    iprot.readStructEnd()
14068 
 
14069 
  def write(self, oprot):
14070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14072 
      return
14073 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
14074 
    if self.orderId is not None:
14075 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14076 
      oprot.writeI64(self.orderId)
14077 
      oprot.writeFieldEnd()
14078 
    if self.isAuthorized is not None:
14079 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14080 
      oprot.writeBool(self.isAuthorized)
14081 
      oprot.writeFieldEnd()
14082 
    oprot.writeFieldStop()
14083 
    oprot.writeStructEnd()
14084 
 
14085 
  def validate(self):
14086 
    return
14087 
 
14088 
 
14089 
  def __repr__(self):
14090 
    L = ['%s=%r' % (key, value)
14091 
      for key, value in self.__dict__.iteritems()]
14092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14093 
 
14094 
  def __eq__(self, other):
14095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14096 
 
14097 
  def __ne__(self, other):
14098 
    return not (self == other)
14099 
 
14100 
class markOrderDoaRequestAuthorized_result:
14101 
  """
14102 
  Attributes:
14103 
   - success
14104 
   - ex
14105 
  """
14106 
 
14107 
  thrift_spec = (
14108 
    (0, TType.BOOL, 'success', None, None, ), # 0
14109 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14110 
  )
14111 
 
14112 
  def __init__(self, success=None, ex=None,):
14113 
    self.success = success
14114 
    self.ex = ex
14115 
 
14116 
  def read(self, iprot):
14117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14119 
      return
14120 
    iprot.readStructBegin()
14121 
    while True:
14122 
      (fname, ftype, fid) = iprot.readFieldBegin()
14123 
      if ftype == TType.STOP:
14124 
        break
14125 
      if fid == 0:
14126 
        if ftype == TType.BOOL:
14127 
          self.success = iprot.readBool();
14128 
        else:
14129 
          iprot.skip(ftype)
14130 
      elif fid == 1:
14131 
        if ftype == TType.STRUCT:
14132 
          self.ex = TransactionServiceException()
14133 
          self.ex.read(iprot)
14134 
        else:
14135 
          iprot.skip(ftype)
14136 
      else:
14137 
        iprot.skip(ftype)
14138 
      iprot.readFieldEnd()
14139 
    iprot.readStructEnd()
14140 
 
14141 
  def write(self, oprot):
14142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14144 
      return
14145 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
14146 
    if self.success is not None:
14147 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14148 
      oprot.writeBool(self.success)
14149 
      oprot.writeFieldEnd()
14150 
    if self.ex is not None:
14151 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14152 
      self.ex.write(oprot)
14153 
      oprot.writeFieldEnd()
14154 
    oprot.writeFieldStop()
14155 
    oprot.writeStructEnd()
14156 
 
14157 
  def validate(self):
14158 
    return
14159 
 
14160 
 
14161 
  def __repr__(self):
14162 
    L = ['%s=%r' % (key, value)
14163 
      for key, value in self.__dict__.iteritems()]
14164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14165 
 
14166 
  def __eq__(self, other):
14167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14168 
 
14169 
  def __ne__(self, other):
14170 
    return not (self == other)
14171 
 
4488 rajveer 14172 
class markOrderReturnRequestReceived_args:
14173 
  """
14174 
  Attributes:
14175 
   - orderId
14176 
  """
14177 
 
14178 
  thrift_spec = (
14179 
    None, # 0
14180 
    (1, TType.I64, 'orderId', None, None, ), # 1
14181 
  )
14182 
 
14183 
  def __init__(self, orderId=None,):
14184 
    self.orderId = orderId
14185 
 
14186 
  def read(self, iprot):
14187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14189 
      return
14190 
    iprot.readStructBegin()
14191 
    while True:
14192 
      (fname, ftype, fid) = iprot.readFieldBegin()
14193 
      if ftype == TType.STOP:
14194 
        break
14195 
      if fid == 1:
14196 
        if ftype == TType.I64:
14197 
          self.orderId = iprot.readI64();
14198 
        else:
14199 
          iprot.skip(ftype)
14200 
      else:
14201 
        iprot.skip(ftype)
14202 
      iprot.readFieldEnd()
14203 
    iprot.readStructEnd()
14204 
 
14205 
  def write(self, oprot):
14206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14208 
      return
14209 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
14210 
    if self.orderId is not None:
14211 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14212 
      oprot.writeI64(self.orderId)
14213 
      oprot.writeFieldEnd()
14214 
    oprot.writeFieldStop()
14215 
    oprot.writeStructEnd()
14216 
 
14217 
  def validate(self):
14218 
    return
14219 
 
14220 
 
14221 
  def __repr__(self):
14222 
    L = ['%s=%r' % (key, value)
14223 
      for key, value in self.__dict__.iteritems()]
14224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14225 
 
14226 
  def __eq__(self, other):
14227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14228 
 
14229 
  def __ne__(self, other):
14230 
    return not (self == other)
14231 
 
14232 
class markOrderReturnRequestReceived_result:
14233 
  """
14234 
  Attributes:
14235 
   - success
14236 
   - ex
14237 
  """
14238 
 
14239 
  thrift_spec = (
14240 
    (0, TType.BOOL, 'success', None, None, ), # 0
14241 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14242 
  )
14243 
 
14244 
  def __init__(self, success=None, ex=None,):
14245 
    self.success = success
14246 
    self.ex = ex
14247 
 
14248 
  def read(self, iprot):
14249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14251 
      return
14252 
    iprot.readStructBegin()
14253 
    while True:
14254 
      (fname, ftype, fid) = iprot.readFieldBegin()
14255 
      if ftype == TType.STOP:
14256 
        break
14257 
      if fid == 0:
14258 
        if ftype == TType.BOOL:
14259 
          self.success = iprot.readBool();
14260 
        else:
14261 
          iprot.skip(ftype)
14262 
      elif fid == 1:
14263 
        if ftype == TType.STRUCT:
14264 
          self.ex = TransactionServiceException()
14265 
          self.ex.read(iprot)
14266 
        else:
14267 
          iprot.skip(ftype)
14268 
      else:
14269 
        iprot.skip(ftype)
14270 
      iprot.readFieldEnd()
14271 
    iprot.readStructEnd()
14272 
 
14273 
  def write(self, oprot):
14274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14276 
      return
14277 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
14278 
    if self.success is not None:
14279 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14280 
      oprot.writeBool(self.success)
14281 
      oprot.writeFieldEnd()
14282 
    if self.ex is not None:
14283 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14284 
      self.ex.write(oprot)
14285 
      oprot.writeFieldEnd()
14286 
    oprot.writeFieldStop()
14287 
    oprot.writeStructEnd()
14288 
 
14289 
  def validate(self):
14290 
    return
14291 
 
14292 
 
14293 
  def __repr__(self):
14294 
    L = ['%s=%r' % (key, value)
14295 
      for key, value in self.__dict__.iteritems()]
14296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14297 
 
14298 
  def __eq__(self, other):
14299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14300 
 
14301 
  def __ne__(self, other):
14302 
    return not (self == other)
14303 
 
14304 
class markOrderReturnRequestAuthorized_args:
14305 
  """
14306 
  Attributes:
14307 
   - orderId
14308 
   - isAuthorized
14309 
  """
14310 
 
14311 
  thrift_spec = (
14312 
    None, # 0
14313 
    (1, TType.I64, 'orderId', None, None, ), # 1
14314 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14315 
  )
14316 
 
14317 
  def __init__(self, orderId=None, isAuthorized=None,):
14318 
    self.orderId = orderId
14319 
    self.isAuthorized = isAuthorized
14320 
 
14321 
  def read(self, iprot):
14322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14324 
      return
14325 
    iprot.readStructBegin()
14326 
    while True:
14327 
      (fname, ftype, fid) = iprot.readFieldBegin()
14328 
      if ftype == TType.STOP:
14329 
        break
14330 
      if fid == 1:
14331 
        if ftype == TType.I64:
14332 
          self.orderId = iprot.readI64();
14333 
        else:
14334 
          iprot.skip(ftype)
14335 
      elif fid == 2:
14336 
        if ftype == TType.BOOL:
14337 
          self.isAuthorized = iprot.readBool();
14338 
        else:
14339 
          iprot.skip(ftype)
14340 
      else:
14341 
        iprot.skip(ftype)
14342 
      iprot.readFieldEnd()
14343 
    iprot.readStructEnd()
14344 
 
14345 
  def write(self, oprot):
14346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14348 
      return
14349 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
14350 
    if self.orderId is not None:
14351 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14352 
      oprot.writeI64(self.orderId)
14353 
      oprot.writeFieldEnd()
14354 
    if self.isAuthorized is not None:
14355 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14356 
      oprot.writeBool(self.isAuthorized)
14357 
      oprot.writeFieldEnd()
14358 
    oprot.writeFieldStop()
14359 
    oprot.writeStructEnd()
14360 
 
14361 
  def validate(self):
14362 
    return
14363 
 
14364 
 
14365 
  def __repr__(self):
14366 
    L = ['%s=%r' % (key, value)
14367 
      for key, value in self.__dict__.iteritems()]
14368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14369 
 
14370 
  def __eq__(self, other):
14371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14372 
 
14373 
  def __ne__(self, other):
14374 
    return not (self == other)
14375 
 
14376 
class markOrderReturnRequestAuthorized_result:
14377 
  """
14378 
  Attributes:
14379 
   - success
14380 
   - ex
14381 
  """
14382 
 
14383 
  thrift_spec = (
14384 
    (0, TType.BOOL, 'success', None, None, ), # 0
14385 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14386 
  )
14387 
 
14388 
  def __init__(self, success=None, ex=None,):
14389 
    self.success = success
14390 
    self.ex = ex
14391 
 
14392 
  def read(self, iprot):
14393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14395 
      return
14396 
    iprot.readStructBegin()
14397 
    while True:
14398 
      (fname, ftype, fid) = iprot.readFieldBegin()
14399 
      if ftype == TType.STOP:
14400 
        break
14401 
      if fid == 0:
14402 
        if ftype == TType.BOOL:
14403 
          self.success = iprot.readBool();
14404 
        else:
14405 
          iprot.skip(ftype)
14406 
      elif fid == 1:
14407 
        if ftype == TType.STRUCT:
14408 
          self.ex = TransactionServiceException()
14409 
          self.ex.read(iprot)
14410 
        else:
14411 
          iprot.skip(ftype)
14412 
      else:
14413 
        iprot.skip(ftype)
14414 
      iprot.readFieldEnd()
14415 
    iprot.readStructEnd()
14416 
 
14417 
  def write(self, oprot):
14418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14420 
      return
14421 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
14422 
    if self.success is not None:
14423 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14424 
      oprot.writeBool(self.success)
14425 
      oprot.writeFieldEnd()
14426 
    if self.ex is not None:
14427 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14428 
      self.ex.write(oprot)
14429 
      oprot.writeFieldEnd()
14430 
    oprot.writeFieldStop()
14431 
    oprot.writeStructEnd()
14432 
 
14433 
  def validate(self):
14434 
    return
14435 
 
14436 
 
14437 
  def __repr__(self):
14438 
    L = ['%s=%r' % (key, value)
14439 
      for key, value in self.__dict__.iteritems()]
14440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14441 
 
14442 
  def __eq__(self, other):
14443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14444 
 
14445 
  def __ne__(self, other):
14446 
    return not (self == other)
14447 
 
2536 chandransh 14448 
class requestPickupNumber_args:
14449 
  """
14450 
  Attributes:
14451 
   - orderId
4579 rajveer 14452 
   - providerId
2536 chandransh 14453 
  """
14454 
 
14455 
  thrift_spec = (
14456 
    None, # 0
14457 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 14458 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 14459 
  )
14460 
 
4579 rajveer 14461 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 14462 
    self.orderId = orderId
4579 rajveer 14463 
    self.providerId = providerId
2536 chandransh 14464 
 
14465 
  def read(self, iprot):
14466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14468 
      return
14469 
    iprot.readStructBegin()
14470 
    while True:
14471 
      (fname, ftype, fid) = iprot.readFieldBegin()
14472 
      if ftype == TType.STOP:
14473 
        break
14474 
      if fid == 1:
14475 
        if ftype == TType.I64:
14476 
          self.orderId = iprot.readI64();
14477 
        else:
14478 
          iprot.skip(ftype)
4579 rajveer 14479 
      elif fid == 2:
14480 
        if ftype == TType.I64:
14481 
          self.providerId = iprot.readI64();
14482 
        else:
14483 
          iprot.skip(ftype)
2536 chandransh 14484 
      else:
14485 
        iprot.skip(ftype)
14486 
      iprot.readFieldEnd()
14487 
    iprot.readStructEnd()
14488 
 
14489 
  def write(self, oprot):
14490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14492 
      return
14493 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 14494 
    if self.orderId is not None:
2536 chandransh 14495 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14496 
      oprot.writeI64(self.orderId)
14497 
      oprot.writeFieldEnd()
4579 rajveer 14498 
    if self.providerId is not None:
14499 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
14500 
      oprot.writeI64(self.providerId)
14501 
      oprot.writeFieldEnd()
2536 chandransh 14502 
    oprot.writeFieldStop()
14503 
    oprot.writeStructEnd()
14504 
 
3431 rajveer 14505 
  def validate(self):
14506 
    return
14507 
 
14508 
 
2536 chandransh 14509 
  def __repr__(self):
14510 
    L = ['%s=%r' % (key, value)
14511 
      for key, value in self.__dict__.iteritems()]
14512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14513 
 
14514 
  def __eq__(self, other):
14515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14516 
 
14517 
  def __ne__(self, other):
14518 
    return not (self == other)
14519 
 
14520 
class requestPickupNumber_result:
14521 
  """
14522 
  Attributes:
14523 
   - success
14524 
   - ex
14525 
  """
14526 
 
14527 
  thrift_spec = (
14528 
    (0, TType.BOOL, 'success', None, None, ), # 0
14529 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14530 
  )
14531 
 
14532 
  def __init__(self, success=None, ex=None,):
14533 
    self.success = success
14534 
    self.ex = ex
14535 
 
14536 
  def read(self, iprot):
14537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14539 
      return
14540 
    iprot.readStructBegin()
14541 
    while True:
14542 
      (fname, ftype, fid) = iprot.readFieldBegin()
14543 
      if ftype == TType.STOP:
14544 
        break
14545 
      if fid == 0:
14546 
        if ftype == TType.BOOL:
14547 
          self.success = iprot.readBool();
14548 
        else:
14549 
          iprot.skip(ftype)
14550 
      elif fid == 1:
14551 
        if ftype == TType.STRUCT:
14552 
          self.ex = TransactionServiceException()
14553 
          self.ex.read(iprot)
14554 
        else:
14555 
          iprot.skip(ftype)
14556 
      else:
14557 
        iprot.skip(ftype)
14558 
      iprot.readFieldEnd()
14559 
    iprot.readStructEnd()
14560 
 
14561 
  def write(self, oprot):
14562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14564 
      return
14565 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 14566 
    if self.success is not None:
2536 chandransh 14567 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14568 
      oprot.writeBool(self.success)
14569 
      oprot.writeFieldEnd()
3431 rajveer 14570 
    if self.ex is not None:
2536 chandransh 14571 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14572 
      self.ex.write(oprot)
14573 
      oprot.writeFieldEnd()
14574 
    oprot.writeFieldStop()
14575 
    oprot.writeStructEnd()
14576 
 
3431 rajveer 14577 
  def validate(self):
14578 
    return
14579 
 
14580 
 
2536 chandransh 14581 
  def __repr__(self):
14582 
    L = ['%s=%r' % (key, value)
14583 
      for key, value in self.__dict__.iteritems()]
14584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14585 
 
14586 
  def __eq__(self, other):
14587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14588 
 
14589 
  def __ne__(self, other):
14590 
    return not (self == other)
14591 
 
14592 
class authorizePickup_args:
14593 
  """
14594 
  Attributes:
14595 
   - orderId
14596 
   - pickupNumber
4602 rajveer 14597 
   - providerId
2536 chandransh 14598 
  """
14599 
 
14600 
  thrift_spec = (
14601 
    None, # 0
14602 
    (1, TType.I64, 'orderId', None, None, ), # 1
14603 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 14604 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 14605 
  )
14606 
 
4602 rajveer 14607 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 14608 
    self.orderId = orderId
14609 
    self.pickupNumber = pickupNumber
4602 rajveer 14610 
    self.providerId = providerId
2536 chandransh 14611 
 
14612 
  def read(self, iprot):
14613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14615 
      return
14616 
    iprot.readStructBegin()
14617 
    while True:
14618 
      (fname, ftype, fid) = iprot.readFieldBegin()
14619 
      if ftype == TType.STOP:
14620 
        break
14621 
      if fid == 1:
14622 
        if ftype == TType.I64:
14623 
          self.orderId = iprot.readI64();
14624 
        else:
14625 
          iprot.skip(ftype)
14626 
      elif fid == 2:
14627 
        if ftype == TType.STRING:
14628 
          self.pickupNumber = iprot.readString();
14629 
        else:
14630 
          iprot.skip(ftype)
4602 rajveer 14631 
      elif fid == 3:
14632 
        if ftype == TType.I64:
14633 
          self.providerId = iprot.readI64();
14634 
        else:
14635 
          iprot.skip(ftype)
2536 chandransh 14636 
      else:
14637 
        iprot.skip(ftype)
14638 
      iprot.readFieldEnd()
14639 
    iprot.readStructEnd()
14640 
 
14641 
  def write(self, oprot):
14642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14644 
      return
14645 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 14646 
    if self.orderId is not None:
2536 chandransh 14647 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14648 
      oprot.writeI64(self.orderId)
14649 
      oprot.writeFieldEnd()
3431 rajveer 14650 
    if self.pickupNumber is not None:
2536 chandransh 14651 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
14652 
      oprot.writeString(self.pickupNumber)
14653 
      oprot.writeFieldEnd()
4602 rajveer 14654 
    if self.providerId is not None:
14655 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
14656 
      oprot.writeI64(self.providerId)
14657 
      oprot.writeFieldEnd()
2536 chandransh 14658 
    oprot.writeFieldStop()
14659 
    oprot.writeStructEnd()
14660 
 
3431 rajveer 14661 
  def validate(self):
14662 
    return
14663 
 
14664 
 
2536 chandransh 14665 
  def __repr__(self):
14666 
    L = ['%s=%r' % (key, value)
14667 
      for key, value in self.__dict__.iteritems()]
14668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14669 
 
14670 
  def __eq__(self, other):
14671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14672 
 
14673 
  def __ne__(self, other):
14674 
    return not (self == other)
14675 
 
14676 
class authorizePickup_result:
14677 
  """
14678 
  Attributes:
14679 
   - success
14680 
   - ex
14681 
  """
14682 
 
14683 
  thrift_spec = (
14684 
    (0, TType.BOOL, 'success', None, None, ), # 0
14685 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14686 
  )
14687 
 
14688 
  def __init__(self, success=None, ex=None,):
14689 
    self.success = success
14690 
    self.ex = ex
14691 
 
14692 
  def read(self, iprot):
14693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14695 
      return
14696 
    iprot.readStructBegin()
14697 
    while True:
14698 
      (fname, ftype, fid) = iprot.readFieldBegin()
14699 
      if ftype == TType.STOP:
14700 
        break
14701 
      if fid == 0:
14702 
        if ftype == TType.BOOL:
14703 
          self.success = iprot.readBool();
14704 
        else:
14705 
          iprot.skip(ftype)
14706 
      elif fid == 1:
14707 
        if ftype == TType.STRUCT:
14708 
          self.ex = TransactionServiceException()
14709 
          self.ex.read(iprot)
14710 
        else:
14711 
          iprot.skip(ftype)
14712 
      else:
14713 
        iprot.skip(ftype)
14714 
      iprot.readFieldEnd()
14715 
    iprot.readStructEnd()
14716 
 
14717 
  def write(self, oprot):
14718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14720 
      return
14721 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 14722 
    if self.success is not None:
2536 chandransh 14723 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14724 
      oprot.writeBool(self.success)
14725 
      oprot.writeFieldEnd()
3431 rajveer 14726 
    if self.ex is not None:
2536 chandransh 14727 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14728 
      self.ex.write(oprot)
14729 
      oprot.writeFieldEnd()
14730 
    oprot.writeFieldStop()
14731 
    oprot.writeStructEnd()
14732 
 
3431 rajveer 14733 
  def validate(self):
14734 
    return
14735 
 
14736 
 
2536 chandransh 14737 
  def __repr__(self):
14738 
    L = ['%s=%r' % (key, value)
14739 
      for key, value in self.__dict__.iteritems()]
14740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14741 
 
14742 
  def __eq__(self, other):
14743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14744 
 
14745 
  def __ne__(self, other):
14746 
    return not (self == other)
14747 
 
2764 chandransh 14748 
class markDoasAsPickedUp_args:
14749 
  """
14750 
  Attributes:
14751 
   - providerId
14752 
   - pickupDetails
14753 
  """
14754 
 
14755 
  thrift_spec = (
14756 
    None, # 0
14757 
    (1, TType.I64, 'providerId', None, None, ), # 1
14758 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
14759 
  )
14760 
 
14761 
  def __init__(self, providerId=None, pickupDetails=None,):
14762 
    self.providerId = providerId
14763 
    self.pickupDetails = pickupDetails
14764 
 
14765 
  def read(self, iprot):
14766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14768 
      return
14769 
    iprot.readStructBegin()
14770 
    while True:
14771 
      (fname, ftype, fid) = iprot.readFieldBegin()
14772 
      if ftype == TType.STOP:
14773 
        break
14774 
      if fid == 1:
14775 
        if ftype == TType.I64:
14776 
          self.providerId = iprot.readI64();
14777 
        else:
14778 
          iprot.skip(ftype)
14779 
      elif fid == 2:
14780 
        if ftype == TType.MAP:
14781 
          self.pickupDetails = {}
5031 varun.gupt 14782 
          (_ktype323, _vtype324, _size322 ) = iprot.readMapBegin()
14783 
          for _i326 in xrange(_size322):
14784 
            _key327 = iprot.readString();
14785 
            _val328 = iprot.readString();
14786 
            self.pickupDetails[_key327] = _val328
2764 chandransh 14787 
          iprot.readMapEnd()
14788 
        else:
14789 
          iprot.skip(ftype)
14790 
      else:
14791 
        iprot.skip(ftype)
14792 
      iprot.readFieldEnd()
14793 
    iprot.readStructEnd()
14794 
 
14795 
  def write(self, oprot):
14796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14798 
      return
14799 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 14800 
    if self.providerId is not None:
2764 chandransh 14801 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14802 
      oprot.writeI64(self.providerId)
14803 
      oprot.writeFieldEnd()
3431 rajveer 14804 
    if self.pickupDetails is not None:
2764 chandransh 14805 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14806 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 14807 
      for kiter329,viter330 in self.pickupDetails.items():
14808 
        oprot.writeString(kiter329)
14809 
        oprot.writeString(viter330)
2764 chandransh 14810 
      oprot.writeMapEnd()
14811 
      oprot.writeFieldEnd()
14812 
    oprot.writeFieldStop()
14813 
    oprot.writeStructEnd()
14814 
 
3431 rajveer 14815 
  def validate(self):
14816 
    return
14817 
 
14818 
 
2764 chandransh 14819 
  def __repr__(self):
14820 
    L = ['%s=%r' % (key, value)
14821 
      for key, value in self.__dict__.iteritems()]
14822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14823 
 
14824 
  def __eq__(self, other):
14825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14826 
 
14827 
  def __ne__(self, other):
14828 
    return not (self == other)
14829 
 
14830 
class markDoasAsPickedUp_result:
4910 phani.kuma 14831 
 
14832 
  thrift_spec = (
14833 
  )
14834 
 
14835 
  def read(self, iprot):
14836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14838 
      return
14839 
    iprot.readStructBegin()
14840 
    while True:
14841 
      (fname, ftype, fid) = iprot.readFieldBegin()
14842 
      if ftype == TType.STOP:
14843 
        break
14844 
      else:
14845 
        iprot.skip(ftype)
14846 
      iprot.readFieldEnd()
14847 
    iprot.readStructEnd()
14848 
 
14849 
  def write(self, oprot):
14850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14852 
      return
14853 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
14854 
    oprot.writeFieldStop()
14855 
    oprot.writeStructEnd()
14856 
 
14857 
  def validate(self):
14858 
    return
14859 
 
14860 
 
14861 
  def __repr__(self):
14862 
    L = ['%s=%r' % (key, value)
14863 
      for key, value in self.__dict__.iteritems()]
14864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14865 
 
14866 
  def __eq__(self, other):
14867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14868 
 
14869 
  def __ne__(self, other):
14870 
    return not (self == other)
14871 
 
14872 
class getDoasNotPickedUp_args:
2764 chandransh 14873 
  """
14874 
  Attributes:
4910 phani.kuma 14875 
   - providerId
14876 
  """
14877 
 
14878 
  thrift_spec = (
14879 
    None, # 0
14880 
    (1, TType.I64, 'providerId', None, None, ), # 1
14881 
  )
14882 
 
14883 
  def __init__(self, providerId=None,):
14884 
    self.providerId = providerId
14885 
 
14886 
  def read(self, iprot):
14887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14889 
      return
14890 
    iprot.readStructBegin()
14891 
    while True:
14892 
      (fname, ftype, fid) = iprot.readFieldBegin()
14893 
      if ftype == TType.STOP:
14894 
        break
14895 
      if fid == 1:
14896 
        if ftype == TType.I64:
14897 
          self.providerId = iprot.readI64();
14898 
        else:
14899 
          iprot.skip(ftype)
14900 
      else:
14901 
        iprot.skip(ftype)
14902 
      iprot.readFieldEnd()
14903 
    iprot.readStructEnd()
14904 
 
14905 
  def write(self, oprot):
14906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14908 
      return
14909 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
14910 
    if self.providerId is not None:
14911 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14912 
      oprot.writeI64(self.providerId)
14913 
      oprot.writeFieldEnd()
14914 
    oprot.writeFieldStop()
14915 
    oprot.writeStructEnd()
14916 
 
14917 
  def validate(self):
14918 
    return
14919 
 
14920 
 
14921 
  def __repr__(self):
14922 
    L = ['%s=%r' % (key, value)
14923 
      for key, value in self.__dict__.iteritems()]
14924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14925 
 
14926 
  def __eq__(self, other):
14927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14928 
 
14929 
  def __ne__(self, other):
14930 
    return not (self == other)
14931 
 
14932 
class getDoasNotPickedUp_result:
14933 
  """
14934 
  Attributes:
2764 chandransh 14935 
   - success
14936 
  """
14937 
 
14938 
  thrift_spec = (
14939 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14940 
  )
14941 
 
14942 
  def __init__(self, success=None,):
14943 
    self.success = success
14944 
 
14945 
  def read(self, iprot):
14946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14948 
      return
14949 
    iprot.readStructBegin()
14950 
    while True:
14951 
      (fname, ftype, fid) = iprot.readFieldBegin()
14952 
      if ftype == TType.STOP:
14953 
        break
14954 
      if fid == 0:
14955 
        if ftype == TType.LIST:
14956 
          self.success = []
5031 varun.gupt 14957 
          (_etype334, _size331) = iprot.readListBegin()
14958 
          for _i335 in xrange(_size331):
14959 
            _elem336 = Order()
14960 
            _elem336.read(iprot)
14961 
            self.success.append(_elem336)
2764 chandransh 14962 
          iprot.readListEnd()
14963 
        else:
14964 
          iprot.skip(ftype)
14965 
      else:
14966 
        iprot.skip(ftype)
14967 
      iprot.readFieldEnd()
14968 
    iprot.readStructEnd()
14969 
 
14970 
  def write(self, oprot):
14971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14973 
      return
4910 phani.kuma 14974 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 14975 
    if self.success is not None:
2764 chandransh 14976 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14977 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 14978 
      for iter337 in self.success:
14979 
        iter337.write(oprot)
2764 chandransh 14980 
      oprot.writeListEnd()
14981 
      oprot.writeFieldEnd()
14982 
    oprot.writeFieldStop()
14983 
    oprot.writeStructEnd()
14984 
 
3431 rajveer 14985 
  def validate(self):
14986 
    return
14987 
 
14988 
 
2764 chandransh 14989 
  def __repr__(self):
14990 
    L = ['%s=%r' % (key, value)
14991 
      for key, value in self.__dict__.iteritems()]
14992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14993 
 
14994 
  def __eq__(self, other):
14995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14996 
 
14997 
  def __ne__(self, other):
14998 
    return not (self == other)
14999 
 
4741 phani.kuma 15000 
class markReturnOrdersAsPickedUp_args:
15001 
  """
15002 
  Attributes:
15003 
   - providerId
15004 
   - pickupDetails
15005 
  """
15006 
 
15007 
  thrift_spec = (
15008 
    None, # 0
15009 
    (1, TType.I64, 'providerId', None, None, ), # 1
15010 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
15011 
  )
15012 
 
15013 
  def __init__(self, providerId=None, pickupDetails=None,):
15014 
    self.providerId = providerId
15015 
    self.pickupDetails = pickupDetails
15016 
 
15017 
  def read(self, iprot):
15018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15020 
      return
15021 
    iprot.readStructBegin()
15022 
    while True:
15023 
      (fname, ftype, fid) = iprot.readFieldBegin()
15024 
      if ftype == TType.STOP:
15025 
        break
15026 
      if fid == 1:
15027 
        if ftype == TType.I64:
15028 
          self.providerId = iprot.readI64();
15029 
        else:
15030 
          iprot.skip(ftype)
15031 
      elif fid == 2:
15032 
        if ftype == TType.MAP:
15033 
          self.pickupDetails = {}
5031 varun.gupt 15034 
          (_ktype339, _vtype340, _size338 ) = iprot.readMapBegin()
15035 
          for _i342 in xrange(_size338):
15036 
            _key343 = iprot.readString();
15037 
            _val344 = iprot.readString();
15038 
            self.pickupDetails[_key343] = _val344
4741 phani.kuma 15039 
          iprot.readMapEnd()
15040 
        else:
15041 
          iprot.skip(ftype)
15042 
      else:
15043 
        iprot.skip(ftype)
15044 
      iprot.readFieldEnd()
15045 
    iprot.readStructEnd()
15046 
 
15047 
  def write(self, oprot):
15048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15050 
      return
15051 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
15052 
    if self.providerId is not None:
15053 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15054 
      oprot.writeI64(self.providerId)
15055 
      oprot.writeFieldEnd()
15056 
    if self.pickupDetails is not None:
15057 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15058 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 15059 
      for kiter345,viter346 in self.pickupDetails.items():
15060 
        oprot.writeString(kiter345)
15061 
        oprot.writeString(viter346)
4741 phani.kuma 15062 
      oprot.writeMapEnd()
15063 
      oprot.writeFieldEnd()
15064 
    oprot.writeFieldStop()
15065 
    oprot.writeStructEnd()
15066 
 
15067 
  def validate(self):
15068 
    return
15069 
 
15070 
 
15071 
  def __repr__(self):
15072 
    L = ['%s=%r' % (key, value)
15073 
      for key, value in self.__dict__.iteritems()]
15074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15075 
 
15076 
  def __eq__(self, other):
15077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15078 
 
15079 
  def __ne__(self, other):
15080 
    return not (self == other)
15081 
 
15082 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 15083 
 
15084 
  thrift_spec = (
15085 
  )
15086 
 
15087 
  def read(self, iprot):
15088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15090 
      return
15091 
    iprot.readStructBegin()
15092 
    while True:
15093 
      (fname, ftype, fid) = iprot.readFieldBegin()
15094 
      if ftype == TType.STOP:
15095 
        break
15096 
      else:
15097 
        iprot.skip(ftype)
15098 
      iprot.readFieldEnd()
15099 
    iprot.readStructEnd()
15100 
 
15101 
  def write(self, oprot):
15102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15104 
      return
15105 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
15106 
    oprot.writeFieldStop()
15107 
    oprot.writeStructEnd()
15108 
 
15109 
  def validate(self):
15110 
    return
15111 
 
15112 
 
15113 
  def __repr__(self):
15114 
    L = ['%s=%r' % (key, value)
15115 
      for key, value in self.__dict__.iteritems()]
15116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15117 
 
15118 
  def __eq__(self, other):
15119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15120 
 
15121 
  def __ne__(self, other):
15122 
    return not (self == other)
15123 
 
15124 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 15125 
  """
15126 
  Attributes:
4910 phani.kuma 15127 
   - providerId
15128 
  """
15129 
 
15130 
  thrift_spec = (
15131 
    None, # 0
15132 
    (1, TType.I64, 'providerId', None, None, ), # 1
15133 
  )
15134 
 
15135 
  def __init__(self, providerId=None,):
15136 
    self.providerId = providerId
15137 
 
15138 
  def read(self, iprot):
15139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15141 
      return
15142 
    iprot.readStructBegin()
15143 
    while True:
15144 
      (fname, ftype, fid) = iprot.readFieldBegin()
15145 
      if ftype == TType.STOP:
15146 
        break
15147 
      if fid == 1:
15148 
        if ftype == TType.I64:
15149 
          self.providerId = iprot.readI64();
15150 
        else:
15151 
          iprot.skip(ftype)
15152 
      else:
15153 
        iprot.skip(ftype)
15154 
      iprot.readFieldEnd()
15155 
    iprot.readStructEnd()
15156 
 
15157 
  def write(self, oprot):
15158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15160 
      return
15161 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
15162 
    if self.providerId is not None:
15163 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15164 
      oprot.writeI64(self.providerId)
15165 
      oprot.writeFieldEnd()
15166 
    oprot.writeFieldStop()
15167 
    oprot.writeStructEnd()
15168 
 
15169 
  def validate(self):
15170 
    return
15171 
 
15172 
 
15173 
  def __repr__(self):
15174 
    L = ['%s=%r' % (key, value)
15175 
      for key, value in self.__dict__.iteritems()]
15176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15177 
 
15178 
  def __eq__(self, other):
15179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15180 
 
15181 
  def __ne__(self, other):
15182 
    return not (self == other)
15183 
 
15184 
class getReturnOrdersNotPickedUp_result:
15185 
  """
15186 
  Attributes:
4741 phani.kuma 15187 
   - success
15188 
  """
15189 
 
15190 
  thrift_spec = (
15191 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15192 
  )
15193 
 
15194 
  def __init__(self, success=None,):
15195 
    self.success = success
15196 
 
15197 
  def read(self, iprot):
15198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15200 
      return
15201 
    iprot.readStructBegin()
15202 
    while True:
15203 
      (fname, ftype, fid) = iprot.readFieldBegin()
15204 
      if ftype == TType.STOP:
15205 
        break
15206 
      if fid == 0:
15207 
        if ftype == TType.LIST:
15208 
          self.success = []
5031 varun.gupt 15209 
          (_etype350, _size347) = iprot.readListBegin()
15210 
          for _i351 in xrange(_size347):
15211 
            _elem352 = Order()
15212 
            _elem352.read(iprot)
15213 
            self.success.append(_elem352)
4741 phani.kuma 15214 
          iprot.readListEnd()
15215 
        else:
15216 
          iprot.skip(ftype)
15217 
      else:
15218 
        iprot.skip(ftype)
15219 
      iprot.readFieldEnd()
15220 
    iprot.readStructEnd()
15221 
 
15222 
  def write(self, oprot):
15223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15225 
      return
4910 phani.kuma 15226 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 15227 
    if self.success is not None:
15228 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15229 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 15230 
      for iter353 in self.success:
15231 
        iter353.write(oprot)
4741 phani.kuma 15232 
      oprot.writeListEnd()
15233 
      oprot.writeFieldEnd()
15234 
    oprot.writeFieldStop()
15235 
    oprot.writeStructEnd()
15236 
 
15237 
  def validate(self):
15238 
    return
15239 
 
15240 
 
15241 
  def __repr__(self):
15242 
    L = ['%s=%r' % (key, value)
15243 
      for key, value in self.__dict__.iteritems()]
15244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15245 
 
15246 
  def __eq__(self, other):
15247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15248 
 
15249 
  def __ne__(self, other):
15250 
    return not (self == other)
15251 
 
2616 chandransh 15252 
class receiveReturn_args:
2591 chandransh 15253 
  """
15254 
  Attributes:
15255 
   - orderId
4479 rajveer 15256 
   - receiveCondition
2591 chandransh 15257 
  """
2536 chandransh 15258 
 
2591 chandransh 15259 
  thrift_spec = (
15260 
    None, # 0
15261 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 15262 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 15263 
  )
15264 
 
4479 rajveer 15265 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 15266 
    self.orderId = orderId
4479 rajveer 15267 
    self.receiveCondition = receiveCondition
2591 chandransh 15268 
 
15269 
  def read(self, iprot):
15270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15272 
      return
15273 
    iprot.readStructBegin()
15274 
    while True:
15275 
      (fname, ftype, fid) = iprot.readFieldBegin()
15276 
      if ftype == TType.STOP:
15277 
        break
15278 
      if fid == 1:
15279 
        if ftype == TType.I64:
15280 
          self.orderId = iprot.readI64();
15281 
        else:
15282 
          iprot.skip(ftype)
4479 rajveer 15283 
      elif fid == 2:
15284 
        if ftype == TType.I64:
15285 
          self.receiveCondition = iprot.readI64();
15286 
        else:
15287 
          iprot.skip(ftype)
2591 chandransh 15288 
      else:
15289 
        iprot.skip(ftype)
15290 
      iprot.readFieldEnd()
15291 
    iprot.readStructEnd()
15292 
 
15293 
  def write(self, oprot):
15294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15296 
      return
2616 chandransh 15297 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 15298 
    if self.orderId is not None:
2591 chandransh 15299 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15300 
      oprot.writeI64(self.orderId)
15301 
      oprot.writeFieldEnd()
4479 rajveer 15302 
    if self.receiveCondition is not None:
15303 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
15304 
      oprot.writeI64(self.receiveCondition)
15305 
      oprot.writeFieldEnd()
2591 chandransh 15306 
    oprot.writeFieldStop()
15307 
    oprot.writeStructEnd()
15308 
 
3431 rajveer 15309 
  def validate(self):
15310 
    return
15311 
 
15312 
 
2591 chandransh 15313 
  def __repr__(self):
15314 
    L = ['%s=%r' % (key, value)
15315 
      for key, value in self.__dict__.iteritems()]
15316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15317 
 
15318 
  def __eq__(self, other):
15319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15320 
 
15321 
  def __ne__(self, other):
15322 
    return not (self == other)
15323 
 
2616 chandransh 15324 
class receiveReturn_result:
2591 chandransh 15325 
  """
15326 
  Attributes:
15327 
   - success
15328 
   - ex
15329 
  """
15330 
 
15331 
  thrift_spec = (
15332 
    (0, TType.BOOL, 'success', None, None, ), # 0
15333 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15334 
  )
15335 
 
15336 
  def __init__(self, success=None, ex=None,):
15337 
    self.success = success
15338 
    self.ex = ex
15339 
 
15340 
  def read(self, iprot):
15341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15343 
      return
15344 
    iprot.readStructBegin()
15345 
    while True:
15346 
      (fname, ftype, fid) = iprot.readFieldBegin()
15347 
      if ftype == TType.STOP:
15348 
        break
15349 
      if fid == 0:
15350 
        if ftype == TType.BOOL:
15351 
          self.success = iprot.readBool();
15352 
        else:
15353 
          iprot.skip(ftype)
15354 
      elif fid == 1:
15355 
        if ftype == TType.STRUCT:
15356 
          self.ex = TransactionServiceException()
15357 
          self.ex.read(iprot)
15358 
        else:
15359 
          iprot.skip(ftype)
15360 
      else:
15361 
        iprot.skip(ftype)
15362 
      iprot.readFieldEnd()
15363 
    iprot.readStructEnd()
15364 
 
15365 
  def write(self, oprot):
15366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15368 
      return
2616 chandransh 15369 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 15370 
    if self.success is not None:
2591 chandransh 15371 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15372 
      oprot.writeBool(self.success)
15373 
      oprot.writeFieldEnd()
3431 rajveer 15374 
    if self.ex is not None:
2591 chandransh 15375 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15376 
      self.ex.write(oprot)
15377 
      oprot.writeFieldEnd()
15378 
    oprot.writeFieldStop()
15379 
    oprot.writeStructEnd()
15380 
 
3431 rajveer 15381 
  def validate(self):
15382 
    return
15383 
 
15384 
 
2591 chandransh 15385 
  def __repr__(self):
15386 
    L = ['%s=%r' % (key, value)
15387 
      for key, value in self.__dict__.iteritems()]
15388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15389 
 
15390 
  def __eq__(self, other):
15391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15392 
 
15393 
  def __ne__(self, other):
15394 
    return not (self == other)
15395 
 
15396 
class validateDoa_args:
15397 
  """
15398 
  Attributes:
15399 
   - orderId
15400 
   - isValid
15401 
  """
15402 
 
15403 
  thrift_spec = (
15404 
    None, # 0
15405 
    (1, TType.I64, 'orderId', None, None, ), # 1
15406 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
15407 
  )
15408 
 
15409 
  def __init__(self, orderId=None, isValid=None,):
15410 
    self.orderId = orderId
15411 
    self.isValid = isValid
15412 
 
15413 
  def read(self, iprot):
15414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15416 
      return
15417 
    iprot.readStructBegin()
15418 
    while True:
15419 
      (fname, ftype, fid) = iprot.readFieldBegin()
15420 
      if ftype == TType.STOP:
15421 
        break
15422 
      if fid == 1:
15423 
        if ftype == TType.I64:
15424 
          self.orderId = iprot.readI64();
15425 
        else:
15426 
          iprot.skip(ftype)
15427 
      elif fid == 2:
15428 
        if ftype == TType.BOOL:
15429 
          self.isValid = iprot.readBool();
15430 
        else:
15431 
          iprot.skip(ftype)
15432 
      else:
15433 
        iprot.skip(ftype)
15434 
      iprot.readFieldEnd()
15435 
    iprot.readStructEnd()
15436 
 
15437 
  def write(self, oprot):
15438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15440 
      return
15441 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 15442 
    if self.orderId is not None:
2591 chandransh 15443 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15444 
      oprot.writeI64(self.orderId)
15445 
      oprot.writeFieldEnd()
3431 rajveer 15446 
    if self.isValid is not None:
2591 chandransh 15447 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
15448 
      oprot.writeBool(self.isValid)
15449 
      oprot.writeFieldEnd()
15450 
    oprot.writeFieldStop()
15451 
    oprot.writeStructEnd()
15452 
 
3431 rajveer 15453 
  def validate(self):
15454 
    return
15455 
 
15456 
 
2591 chandransh 15457 
  def __repr__(self):
15458 
    L = ['%s=%r' % (key, value)
15459 
      for key, value in self.__dict__.iteritems()]
15460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15461 
 
15462 
  def __eq__(self, other):
15463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15464 
 
15465 
  def __ne__(self, other):
15466 
    return not (self == other)
15467 
 
15468 
class validateDoa_result:
15469 
  """
15470 
  Attributes:
15471 
   - success
15472 
   - ex
15473 
  """
15474 
 
15475 
  thrift_spec = (
15476 
    (0, TType.BOOL, 'success', None, None, ), # 0
15477 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15478 
  )
15479 
 
15480 
  def __init__(self, success=None, ex=None,):
15481 
    self.success = success
15482 
    self.ex = ex
15483 
 
15484 
  def read(self, iprot):
15485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15487 
      return
15488 
    iprot.readStructBegin()
15489 
    while True:
15490 
      (fname, ftype, fid) = iprot.readFieldBegin()
15491 
      if ftype == TType.STOP:
15492 
        break
15493 
      if fid == 0:
15494 
        if ftype == TType.BOOL:
15495 
          self.success = iprot.readBool();
15496 
        else:
15497 
          iprot.skip(ftype)
15498 
      elif fid == 1:
15499 
        if ftype == TType.STRUCT:
15500 
          self.ex = TransactionServiceException()
15501 
          self.ex.read(iprot)
15502 
        else:
15503 
          iprot.skip(ftype)
15504 
      else:
15505 
        iprot.skip(ftype)
15506 
      iprot.readFieldEnd()
15507 
    iprot.readStructEnd()
15508 
 
15509 
  def write(self, oprot):
15510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15512 
      return
15513 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 15514 
    if self.success is not None:
2591 chandransh 15515 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15516 
      oprot.writeBool(self.success)
15517 
      oprot.writeFieldEnd()
3431 rajveer 15518 
    if self.ex is not None:
2591 chandransh 15519 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15520 
      self.ex.write(oprot)
15521 
      oprot.writeFieldEnd()
15522 
    oprot.writeFieldStop()
15523 
    oprot.writeStructEnd()
15524 
 
3431 rajveer 15525 
  def validate(self):
15526 
    return
15527 
 
15528 
 
2591 chandransh 15529 
  def __repr__(self):
15530 
    L = ['%s=%r' % (key, value)
15531 
      for key, value in self.__dict__.iteritems()]
15532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15533 
 
15534 
  def __eq__(self, other):
15535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15536 
 
15537 
  def __ne__(self, other):
15538 
    return not (self == other)
15539 
 
4495 rajveer 15540 
class validateReturnProduct_args:
15541 
  """
15542 
  Attributes:
15543 
   - orderId
15544 
   - isUsable
15545 
  """
15546 
 
15547 
  thrift_spec = (
15548 
    None, # 0
15549 
    (1, TType.I64, 'orderId', None, None, ), # 1
15550 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
15551 
  )
15552 
 
15553 
  def __init__(self, orderId=None, isUsable=None,):
15554 
    self.orderId = orderId
15555 
    self.isUsable = isUsable
15556 
 
15557 
  def read(self, iprot):
15558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15560 
      return
15561 
    iprot.readStructBegin()
15562 
    while True:
15563 
      (fname, ftype, fid) = iprot.readFieldBegin()
15564 
      if ftype == TType.STOP:
15565 
        break
15566 
      if fid == 1:
15567 
        if ftype == TType.I64:
15568 
          self.orderId = iprot.readI64();
15569 
        else:
15570 
          iprot.skip(ftype)
15571 
      elif fid == 2:
15572 
        if ftype == TType.BOOL:
15573 
          self.isUsable = iprot.readBool();
15574 
        else:
15575 
          iprot.skip(ftype)
15576 
      else:
15577 
        iprot.skip(ftype)
15578 
      iprot.readFieldEnd()
15579 
    iprot.readStructEnd()
15580 
 
15581 
  def write(self, oprot):
15582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15584 
      return
15585 
    oprot.writeStructBegin('validateReturnProduct_args')
15586 
    if self.orderId is not None:
15587 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15588 
      oprot.writeI64(self.orderId)
15589 
      oprot.writeFieldEnd()
15590 
    if self.isUsable is not None:
15591 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
15592 
      oprot.writeBool(self.isUsable)
15593 
      oprot.writeFieldEnd()
15594 
    oprot.writeFieldStop()
15595 
    oprot.writeStructEnd()
15596 
 
15597 
  def validate(self):
15598 
    return
15599 
 
15600 
 
15601 
  def __repr__(self):
15602 
    L = ['%s=%r' % (key, value)
15603 
      for key, value in self.__dict__.iteritems()]
15604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15605 
 
15606 
  def __eq__(self, other):
15607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15608 
 
15609 
  def __ne__(self, other):
15610 
    return not (self == other)
15611 
 
15612 
class validateReturnProduct_result:
15613 
  """
15614 
  Attributes:
15615 
   - success
15616 
   - ex
15617 
  """
15618 
 
15619 
  thrift_spec = (
15620 
    (0, TType.BOOL, 'success', None, None, ), # 0
15621 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15622 
  )
15623 
 
15624 
  def __init__(self, success=None, ex=None,):
15625 
    self.success = success
15626 
    self.ex = ex
15627 
 
15628 
  def read(self, iprot):
15629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15631 
      return
15632 
    iprot.readStructBegin()
15633 
    while True:
15634 
      (fname, ftype, fid) = iprot.readFieldBegin()
15635 
      if ftype == TType.STOP:
15636 
        break
15637 
      if fid == 0:
15638 
        if ftype == TType.BOOL:
15639 
          self.success = iprot.readBool();
15640 
        else:
15641 
          iprot.skip(ftype)
15642 
      elif fid == 1:
15643 
        if ftype == TType.STRUCT:
15644 
          self.ex = TransactionServiceException()
15645 
          self.ex.read(iprot)
15646 
        else:
15647 
          iprot.skip(ftype)
15648 
      else:
15649 
        iprot.skip(ftype)
15650 
      iprot.readFieldEnd()
15651 
    iprot.readStructEnd()
15652 
 
15653 
  def write(self, oprot):
15654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15656 
      return
15657 
    oprot.writeStructBegin('validateReturnProduct_result')
15658 
    if self.success is not None:
15659 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15660 
      oprot.writeBool(self.success)
15661 
      oprot.writeFieldEnd()
15662 
    if self.ex is not None:
15663 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15664 
      self.ex.write(oprot)
15665 
      oprot.writeFieldEnd()
15666 
    oprot.writeFieldStop()
15667 
    oprot.writeStructEnd()
15668 
 
15669 
  def validate(self):
15670 
    return
15671 
 
15672 
 
15673 
  def __repr__(self):
15674 
    L = ['%s=%r' % (key, value)
15675 
      for key, value in self.__dict__.iteritems()]
15676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15677 
 
15678 
  def __eq__(self, other):
15679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15680 
 
15681 
  def __ne__(self, other):
15682 
    return not (self == other)
15683 
 
2616 chandransh 15684 
class reshipOrder_args:
15685 
  """
15686 
  Attributes:
15687 
   - orderId
15688 
  """
2591 chandransh 15689 
 
2616 chandransh 15690 
  thrift_spec = (
15691 
    None, # 0
15692 
    (1, TType.I64, 'orderId', None, None, ), # 1
15693 
  )
15694 
 
15695 
  def __init__(self, orderId=None,):
15696 
    self.orderId = orderId
15697 
 
15698 
  def read(self, iprot):
15699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15701 
      return
15702 
    iprot.readStructBegin()
15703 
    while True:
15704 
      (fname, ftype, fid) = iprot.readFieldBegin()
15705 
      if ftype == TType.STOP:
15706 
        break
15707 
      if fid == 1:
15708 
        if ftype == TType.I64:
15709 
          self.orderId = iprot.readI64();
15710 
        else:
15711 
          iprot.skip(ftype)
15712 
      else:
15713 
        iprot.skip(ftype)
15714 
      iprot.readFieldEnd()
15715 
    iprot.readStructEnd()
15716 
 
15717 
  def write(self, oprot):
15718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15720 
      return
15721 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 15722 
    if self.orderId is not None:
2616 chandransh 15723 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15724 
      oprot.writeI64(self.orderId)
15725 
      oprot.writeFieldEnd()
15726 
    oprot.writeFieldStop()
15727 
    oprot.writeStructEnd()
15728 
 
3431 rajveer 15729 
  def validate(self):
15730 
    return
15731 
 
15732 
 
2616 chandransh 15733 
  def __repr__(self):
15734 
    L = ['%s=%r' % (key, value)
15735 
      for key, value in self.__dict__.iteritems()]
15736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15737 
 
15738 
  def __eq__(self, other):
15739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15740 
 
15741 
  def __ne__(self, other):
15742 
    return not (self == other)
15743 
 
15744 
class reshipOrder_result:
15745 
  """
15746 
  Attributes:
15747 
   - success
15748 
   - ex
15749 
  """
15750 
 
15751 
  thrift_spec = (
15752 
    (0, TType.I64, 'success', None, None, ), # 0
15753 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15754 
  )
15755 
 
15756 
  def __init__(self, success=None, ex=None,):
15757 
    self.success = success
15758 
    self.ex = ex
15759 
 
15760 
  def read(self, iprot):
15761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15763 
      return
15764 
    iprot.readStructBegin()
15765 
    while True:
15766 
      (fname, ftype, fid) = iprot.readFieldBegin()
15767 
      if ftype == TType.STOP:
15768 
        break
15769 
      if fid == 0:
15770 
        if ftype == TType.I64:
15771 
          self.success = iprot.readI64();
15772 
        else:
15773 
          iprot.skip(ftype)
15774 
      elif fid == 1:
15775 
        if ftype == TType.STRUCT:
15776 
          self.ex = TransactionServiceException()
15777 
          self.ex.read(iprot)
15778 
        else:
15779 
          iprot.skip(ftype)
15780 
      else:
15781 
        iprot.skip(ftype)
15782 
      iprot.readFieldEnd()
15783 
    iprot.readStructEnd()
15784 
 
15785 
  def write(self, oprot):
15786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15788 
      return
15789 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 15790 
    if self.success is not None:
2616 chandransh 15791 
      oprot.writeFieldBegin('success', TType.I64, 0)
15792 
      oprot.writeI64(self.success)
15793 
      oprot.writeFieldEnd()
3431 rajveer 15794 
    if self.ex is not None:
2616 chandransh 15795 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15796 
      self.ex.write(oprot)
15797 
      oprot.writeFieldEnd()
15798 
    oprot.writeFieldStop()
15799 
    oprot.writeStructEnd()
15800 
 
3431 rajveer 15801 
  def validate(self):
15802 
    return
15803 
 
15804 
 
2616 chandransh 15805 
  def __repr__(self):
15806 
    L = ['%s=%r' % (key, value)
15807 
      for key, value in self.__dict__.iteritems()]
15808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15809 
 
15810 
  def __eq__(self, other):
15811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15812 
 
15813 
  def __ne__(self, other):
15814 
    return not (self == other)
15815 
 
15816 
class refundOrder_args:
15817 
  """
15818 
  Attributes:
15819 
   - orderId
3226 chandransh 15820 
   - refundedBy
15821 
   - reason
2616 chandransh 15822 
  """
15823 
 
15824 
  thrift_spec = (
15825 
    None, # 0
15826 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 15827 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
15828 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 15829 
  )
15830 
 
3226 chandransh 15831 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 15832 
    self.orderId = orderId
3226 chandransh 15833 
    self.refundedBy = refundedBy
15834 
    self.reason = reason
2616 chandransh 15835 
 
15836 
  def read(self, iprot):
15837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15839 
      return
15840 
    iprot.readStructBegin()
15841 
    while True:
15842 
      (fname, ftype, fid) = iprot.readFieldBegin()
15843 
      if ftype == TType.STOP:
15844 
        break
15845 
      if fid == 1:
15846 
        if ftype == TType.I64:
15847 
          self.orderId = iprot.readI64();
15848 
        else:
15849 
          iprot.skip(ftype)
3226 chandransh 15850 
      elif fid == 2:
15851 
        if ftype == TType.STRING:
15852 
          self.refundedBy = iprot.readString();
15853 
        else:
15854 
          iprot.skip(ftype)
15855 
      elif fid == 3:
15856 
        if ftype == TType.STRING:
15857 
          self.reason = iprot.readString();
15858 
        else:
15859 
          iprot.skip(ftype)
2616 chandransh 15860 
      else:
15861 
        iprot.skip(ftype)
15862 
      iprot.readFieldEnd()
15863 
    iprot.readStructEnd()
15864 
 
15865 
  def write(self, oprot):
15866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15868 
      return
15869 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 15870 
    if self.orderId is not None:
2616 chandransh 15871 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15872 
      oprot.writeI64(self.orderId)
15873 
      oprot.writeFieldEnd()
3431 rajveer 15874 
    if self.refundedBy is not None:
3226 chandransh 15875 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
15876 
      oprot.writeString(self.refundedBy)
15877 
      oprot.writeFieldEnd()
3431 rajveer 15878 
    if self.reason is not None:
3226 chandransh 15879 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
15880 
      oprot.writeString(self.reason)
15881 
      oprot.writeFieldEnd()
2616 chandransh 15882 
    oprot.writeFieldStop()
15883 
    oprot.writeStructEnd()
15884 
 
3431 rajveer 15885 
  def validate(self):
15886 
    return
15887 
 
15888 
 
2616 chandransh 15889 
  def __repr__(self):
15890 
    L = ['%s=%r' % (key, value)
15891 
      for key, value in self.__dict__.iteritems()]
15892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15893 
 
15894 
  def __eq__(self, other):
15895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15896 
 
15897 
  def __ne__(self, other):
15898 
    return not (self == other)
15899 
 
15900 
class refundOrder_result:
15901 
  """
15902 
  Attributes:
15903 
   - success
15904 
   - ex
15905 
  """
15906 
 
15907 
  thrift_spec = (
15908 
    (0, TType.BOOL, 'success', None, None, ), # 0
15909 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15910 
  )
15911 
 
15912 
  def __init__(self, success=None, ex=None,):
15913 
    self.success = success
15914 
    self.ex = ex
15915 
 
15916 
  def read(self, iprot):
15917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15919 
      return
15920 
    iprot.readStructBegin()
15921 
    while True:
15922 
      (fname, ftype, fid) = iprot.readFieldBegin()
15923 
      if ftype == TType.STOP:
15924 
        break
15925 
      if fid == 0:
15926 
        if ftype == TType.BOOL:
15927 
          self.success = iprot.readBool();
15928 
        else:
15929 
          iprot.skip(ftype)
15930 
      elif fid == 1:
15931 
        if ftype == TType.STRUCT:
15932 
          self.ex = TransactionServiceException()
15933 
          self.ex.read(iprot)
15934 
        else:
15935 
          iprot.skip(ftype)
15936 
      else:
15937 
        iprot.skip(ftype)
15938 
      iprot.readFieldEnd()
15939 
    iprot.readStructEnd()
15940 
 
15941 
  def write(self, oprot):
15942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15944 
      return
15945 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 15946 
    if self.success is not None:
2616 chandransh 15947 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15948 
      oprot.writeBool(self.success)
15949 
      oprot.writeFieldEnd()
3431 rajveer 15950 
    if self.ex is not None:
2616 chandransh 15951 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15952 
      self.ex.write(oprot)
15953 
      oprot.writeFieldEnd()
15954 
    oprot.writeFieldStop()
15955 
    oprot.writeStructEnd()
15956 
 
3431 rajveer 15957 
  def validate(self):
15958 
    return
15959 
 
15960 
 
2616 chandransh 15961 
  def __repr__(self):
15962 
    L = ['%s=%r' % (key, value)
15963 
      for key, value in self.__dict__.iteritems()]
15964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15965 
 
15966 
  def __eq__(self, other):
15967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15968 
 
15969 
  def __ne__(self, other):
15970 
    return not (self == other)
15971 
 
2690 chandransh 15972 
class getReturnOrders_args:
15973 
  """
15974 
  Attributes:
15975 
   - warehouseId
15976 
   - fromDate
15977 
   - toDate
15978 
  """
2616 chandransh 15979 
 
2690 chandransh 15980 
  thrift_spec = (
15981 
    None, # 0
15982 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
15983 
    (2, TType.I64, 'fromDate', None, None, ), # 2
15984 
    (3, TType.I64, 'toDate', None, None, ), # 3
15985 
  )
15986 
 
15987 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
15988 
    self.warehouseId = warehouseId
15989 
    self.fromDate = fromDate
15990 
    self.toDate = toDate
15991 
 
15992 
  def read(self, iprot):
15993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15995 
      return
15996 
    iprot.readStructBegin()
15997 
    while True:
15998 
      (fname, ftype, fid) = iprot.readFieldBegin()
15999 
      if ftype == TType.STOP:
16000 
        break
16001 
      if fid == 1:
16002 
        if ftype == TType.I64:
16003 
          self.warehouseId = iprot.readI64();
16004 
        else:
16005 
          iprot.skip(ftype)
16006 
      elif fid == 2:
16007 
        if ftype == TType.I64:
16008 
          self.fromDate = iprot.readI64();
16009 
        else:
16010 
          iprot.skip(ftype)
16011 
      elif fid == 3:
16012 
        if ftype == TType.I64:
16013 
          self.toDate = iprot.readI64();
16014 
        else:
16015 
          iprot.skip(ftype)
16016 
      else:
16017 
        iprot.skip(ftype)
16018 
      iprot.readFieldEnd()
16019 
    iprot.readStructEnd()
16020 
 
16021 
  def write(self, oprot):
16022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16024 
      return
16025 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 16026 
    if self.warehouseId is not None:
2690 chandransh 16027 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
16028 
      oprot.writeI64(self.warehouseId)
16029 
      oprot.writeFieldEnd()
3431 rajveer 16030 
    if self.fromDate is not None:
2690 chandransh 16031 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
16032 
      oprot.writeI64(self.fromDate)
16033 
      oprot.writeFieldEnd()
3431 rajveer 16034 
    if self.toDate is not None:
2690 chandransh 16035 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
16036 
      oprot.writeI64(self.toDate)
16037 
      oprot.writeFieldEnd()
16038 
    oprot.writeFieldStop()
16039 
    oprot.writeStructEnd()
16040 
 
3431 rajveer 16041 
  def validate(self):
16042 
    return
16043 
 
16044 
 
2690 chandransh 16045 
  def __repr__(self):
16046 
    L = ['%s=%r' % (key, value)
16047 
      for key, value in self.__dict__.iteritems()]
16048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16049 
 
16050 
  def __eq__(self, other):
16051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16052 
 
16053 
  def __ne__(self, other):
16054 
    return not (self == other)
16055 
 
16056 
class getReturnOrders_result:
16057 
  """
16058 
  Attributes:
16059 
   - success
16060 
  """
16061 
 
16062 
  thrift_spec = (
16063 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
16064 
  )
16065 
 
16066 
  def __init__(self, success=None,):
16067 
    self.success = success
16068 
 
16069 
  def read(self, iprot):
16070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16072 
      return
16073 
    iprot.readStructBegin()
16074 
    while True:
16075 
      (fname, ftype, fid) = iprot.readFieldBegin()
16076 
      if ftype == TType.STOP:
16077 
        break
16078 
      if fid == 0:
16079 
        if ftype == TType.LIST:
16080 
          self.success = []
5031 varun.gupt 16081 
          (_etype357, _size354) = iprot.readListBegin()
16082 
          for _i358 in xrange(_size354):
16083 
            _elem359 = ReturnOrder()
16084 
            _elem359.read(iprot)
16085 
            self.success.append(_elem359)
2690 chandransh 16086 
          iprot.readListEnd()
16087 
        else:
16088 
          iprot.skip(ftype)
16089 
      else:
16090 
        iprot.skip(ftype)
16091 
      iprot.readFieldEnd()
16092 
    iprot.readStructEnd()
16093 
 
16094 
  def write(self, oprot):
16095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16097 
      return
16098 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 16099 
    if self.success is not None:
2690 chandransh 16100 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16101 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 16102 
      for iter360 in self.success:
16103 
        iter360.write(oprot)
2690 chandransh 16104 
      oprot.writeListEnd()
16105 
      oprot.writeFieldEnd()
16106 
    oprot.writeFieldStop()
16107 
    oprot.writeStructEnd()
16108 
 
3431 rajveer 16109 
  def validate(self):
16110 
    return
16111 
 
16112 
 
2690 chandransh 16113 
  def __repr__(self):
16114 
    L = ['%s=%r' % (key, value)
16115 
      for key, value in self.__dict__.iteritems()]
16116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16117 
 
16118 
  def __eq__(self, other):
16119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16120 
 
16121 
  def __ne__(self, other):
16122 
    return not (self == other)
16123 
 
2700 chandransh 16124 
class getReturnOrder_args:
16125 
  """
16126 
  Attributes:
16127 
   - id
16128 
  """
16129 
 
16130 
  thrift_spec = (
16131 
    None, # 0
16132 
    (1, TType.I64, 'id', None, None, ), # 1
16133 
  )
16134 
 
16135 
  def __init__(self, id=None,):
16136 
    self.id = id
16137 
 
16138 
  def read(self, iprot):
16139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16141 
      return
16142 
    iprot.readStructBegin()
16143 
    while True:
16144 
      (fname, ftype, fid) = iprot.readFieldBegin()
16145 
      if ftype == TType.STOP:
16146 
        break
16147 
      if fid == 1:
16148 
        if ftype == TType.I64:
16149 
          self.id = iprot.readI64();
16150 
        else:
16151 
          iprot.skip(ftype)
16152 
      else:
16153 
        iprot.skip(ftype)
16154 
      iprot.readFieldEnd()
16155 
    iprot.readStructEnd()
16156 
 
16157 
  def write(self, oprot):
16158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16160 
      return
16161 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 16162 
    if self.id is not None:
2700 chandransh 16163 
      oprot.writeFieldBegin('id', TType.I64, 1)
16164 
      oprot.writeI64(self.id)
16165 
      oprot.writeFieldEnd()
16166 
    oprot.writeFieldStop()
16167 
    oprot.writeStructEnd()
16168 
 
3431 rajveer 16169 
  def validate(self):
16170 
    return
16171 
 
16172 
 
2700 chandransh 16173 
  def __repr__(self):
16174 
    L = ['%s=%r' % (key, value)
16175 
      for key, value in self.__dict__.iteritems()]
16176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16177 
 
16178 
  def __eq__(self, other):
16179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16180 
 
16181 
  def __ne__(self, other):
16182 
    return not (self == other)
16183 
 
16184 
class getReturnOrder_result:
16185 
  """
16186 
  Attributes:
16187 
   - success
16188 
   - ex
16189 
  """
16190 
 
16191 
  thrift_spec = (
16192 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
16193 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16194 
  )
16195 
 
16196 
  def __init__(self, success=None, ex=None,):
16197 
    self.success = success
16198 
    self.ex = ex
16199 
 
16200 
  def read(self, iprot):
16201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16203 
      return
16204 
    iprot.readStructBegin()
16205 
    while True:
16206 
      (fname, ftype, fid) = iprot.readFieldBegin()
16207 
      if ftype == TType.STOP:
16208 
        break
16209 
      if fid == 0:
16210 
        if ftype == TType.STRUCT:
16211 
          self.success = ReturnOrder()
16212 
          self.success.read(iprot)
16213 
        else:
16214 
          iprot.skip(ftype)
16215 
      elif fid == 1:
16216 
        if ftype == TType.STRUCT:
16217 
          self.ex = TransactionServiceException()
16218 
          self.ex.read(iprot)
16219 
        else:
16220 
          iprot.skip(ftype)
16221 
      else:
16222 
        iprot.skip(ftype)
16223 
      iprot.readFieldEnd()
16224 
    iprot.readStructEnd()
16225 
 
16226 
  def write(self, oprot):
16227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16229 
      return
16230 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 16231 
    if self.success is not None:
2700 chandransh 16232 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16233 
      self.success.write(oprot)
16234 
      oprot.writeFieldEnd()
3431 rajveer 16235 
    if self.ex is not None:
2700 chandransh 16236 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16237 
      self.ex.write(oprot)
16238 
      oprot.writeFieldEnd()
16239 
    oprot.writeFieldStop()
16240 
    oprot.writeStructEnd()
16241 
 
3431 rajveer 16242 
  def validate(self):
16243 
    return
16244 
 
16245 
 
2700 chandransh 16246 
  def __repr__(self):
16247 
    L = ['%s=%r' % (key, value)
16248 
      for key, value in self.__dict__.iteritems()]
16249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16250 
 
16251 
  def __eq__(self, other):
16252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16253 
 
16254 
  def __ne__(self, other):
16255 
    return not (self == other)
16256 
 
2690 chandransh 16257 
class processReturn_args:
16258 
  """
16259 
  Attributes:
16260 
   - returnOrderId
16261 
  """
16262 
 
16263 
  thrift_spec = (
16264 
    None, # 0
16265 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
16266 
  )
16267 
 
16268 
  def __init__(self, returnOrderId=None,):
16269 
    self.returnOrderId = returnOrderId
16270 
 
16271 
  def read(self, iprot):
16272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16274 
      return
16275 
    iprot.readStructBegin()
16276 
    while True:
16277 
      (fname, ftype, fid) = iprot.readFieldBegin()
16278 
      if ftype == TType.STOP:
16279 
        break
16280 
      if fid == 1:
16281 
        if ftype == TType.I64:
16282 
          self.returnOrderId = iprot.readI64();
16283 
        else:
16284 
          iprot.skip(ftype)
16285 
      else:
16286 
        iprot.skip(ftype)
16287 
      iprot.readFieldEnd()
16288 
    iprot.readStructEnd()
16289 
 
16290 
  def write(self, oprot):
16291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16293 
      return
16294 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 16295 
    if self.returnOrderId is not None:
2690 chandransh 16296 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
16297 
      oprot.writeI64(self.returnOrderId)
16298 
      oprot.writeFieldEnd()
16299 
    oprot.writeFieldStop()
16300 
    oprot.writeStructEnd()
16301 
 
3431 rajveer 16302 
  def validate(self):
16303 
    return
16304 
 
16305 
 
2690 chandransh 16306 
  def __repr__(self):
16307 
    L = ['%s=%r' % (key, value)
16308 
      for key, value in self.__dict__.iteritems()]
16309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16310 
 
16311 
  def __eq__(self, other):
16312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16313 
 
16314 
  def __ne__(self, other):
16315 
    return not (self == other)
16316 
 
16317 
class processReturn_result:
16318 
  """
16319 
  Attributes:
16320 
   - ex
16321 
  """
16322 
 
16323 
  thrift_spec = (
16324 
    None, # 0
16325 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16326 
  )
16327 
 
16328 
  def __init__(self, ex=None,):
16329 
    self.ex = ex
16330 
 
16331 
  def read(self, iprot):
16332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16334 
      return
16335 
    iprot.readStructBegin()
16336 
    while True:
16337 
      (fname, ftype, fid) = iprot.readFieldBegin()
16338 
      if ftype == TType.STOP:
16339 
        break
16340 
      if fid == 1:
16341 
        if ftype == TType.STRUCT:
16342 
          self.ex = TransactionServiceException()
16343 
          self.ex.read(iprot)
16344 
        else:
16345 
          iprot.skip(ftype)
16346 
      else:
16347 
        iprot.skip(ftype)
16348 
      iprot.readFieldEnd()
16349 
    iprot.readStructEnd()
16350 
 
16351 
  def write(self, oprot):
16352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16354 
      return
16355 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 16356 
    if self.ex is not None:
2690 chandransh 16357 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16358 
      self.ex.write(oprot)
16359 
      oprot.writeFieldEnd()
16360 
    oprot.writeFieldStop()
16361 
    oprot.writeStructEnd()
16362 
 
3431 rajveer 16363 
  def validate(self):
16364 
    return
16365 
 
16366 
 
2690 chandransh 16367 
  def __repr__(self):
16368 
    L = ['%s=%r' % (key, value)
16369 
      for key, value in self.__dict__.iteritems()]
16370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16371 
 
16372 
  def __eq__(self, other):
16373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16374 
 
16375 
  def __ne__(self, other):
16376 
    return not (self == other)
16377 
 
3451 chandransh 16378 
class updateWeight_args:
16379 
  """
16380 
  Attributes:
16381 
   - orderId
16382 
   - weight
16383 
  """
16384 
 
16385 
  thrift_spec = (
16386 
    None, # 0
16387 
    (1, TType.I64, 'orderId', None, None, ), # 1
16388 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
16389 
  )
16390 
 
16391 
  def __init__(self, orderId=None, weight=None,):
16392 
    self.orderId = orderId
16393 
    self.weight = weight
16394 
 
16395 
  def read(self, iprot):
16396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16398 
      return
16399 
    iprot.readStructBegin()
16400 
    while True:
16401 
      (fname, ftype, fid) = iprot.readFieldBegin()
16402 
      if ftype == TType.STOP:
16403 
        break
16404 
      if fid == 1:
16405 
        if ftype == TType.I64:
16406 
          self.orderId = iprot.readI64();
16407 
        else:
16408 
          iprot.skip(ftype)
16409 
      elif fid == 2:
16410 
        if ftype == TType.DOUBLE:
16411 
          self.weight = iprot.readDouble();
16412 
        else:
16413 
          iprot.skip(ftype)
16414 
      else:
16415 
        iprot.skip(ftype)
16416 
      iprot.readFieldEnd()
16417 
    iprot.readStructEnd()
16418 
 
16419 
  def write(self, oprot):
16420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16422 
      return
16423 
    oprot.writeStructBegin('updateWeight_args')
16424 
    if self.orderId is not None:
16425 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16426 
      oprot.writeI64(self.orderId)
16427 
      oprot.writeFieldEnd()
16428 
    if self.weight is not None:
16429 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
16430 
      oprot.writeDouble(self.weight)
16431 
      oprot.writeFieldEnd()
16432 
    oprot.writeFieldStop()
16433 
    oprot.writeStructEnd()
16434 
 
16435 
  def validate(self):
16436 
    return
16437 
 
16438 
 
16439 
  def __repr__(self):
16440 
    L = ['%s=%r' % (key, value)
16441 
      for key, value in self.__dict__.iteritems()]
16442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16443 
 
16444 
  def __eq__(self, other):
16445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16446 
 
16447 
  def __ne__(self, other):
16448 
    return not (self == other)
16449 
 
16450 
class updateWeight_result:
16451 
  """
16452 
  Attributes:
16453 
   - success
16454 
   - ex
16455 
  """
16456 
 
16457 
  thrift_spec = (
16458 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16459 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16460 
  )
16461 
 
16462 
  def __init__(self, success=None, ex=None,):
16463 
    self.success = success
16464 
    self.ex = ex
16465 
 
16466 
  def read(self, iprot):
16467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16469 
      return
16470 
    iprot.readStructBegin()
16471 
    while True:
16472 
      (fname, ftype, fid) = iprot.readFieldBegin()
16473 
      if ftype == TType.STOP:
16474 
        break
16475 
      if fid == 0:
16476 
        if ftype == TType.STRUCT:
16477 
          self.success = Order()
16478 
          self.success.read(iprot)
16479 
        else:
16480 
          iprot.skip(ftype)
16481 
      elif fid == 1:
16482 
        if ftype == TType.STRUCT:
16483 
          self.ex = TransactionServiceException()
16484 
          self.ex.read(iprot)
16485 
        else:
16486 
          iprot.skip(ftype)
16487 
      else:
16488 
        iprot.skip(ftype)
16489 
      iprot.readFieldEnd()
16490 
    iprot.readStructEnd()
16491 
 
16492 
  def write(self, oprot):
16493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16495 
      return
16496 
    oprot.writeStructBegin('updateWeight_result')
16497 
    if self.success is not None:
16498 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16499 
      self.success.write(oprot)
16500 
      oprot.writeFieldEnd()
16501 
    if self.ex is not None:
16502 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16503 
      self.ex.write(oprot)
16504 
      oprot.writeFieldEnd()
16505 
    oprot.writeFieldStop()
16506 
    oprot.writeStructEnd()
16507 
 
16508 
  def validate(self):
16509 
    return
16510 
 
16511 
 
16512 
  def __repr__(self):
16513 
    L = ['%s=%r' % (key, value)
16514 
      for key, value in self.__dict__.iteritems()]
16515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16516 
 
16517 
  def __eq__(self, other):
16518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16519 
 
16520 
  def __ne__(self, other):
16521 
    return not (self == other)
3469 chandransh 16522 
 
16523 
class changeItem_args:
16524 
  """
16525 
  Attributes:
16526 
   - orderId
16527 
   - itemId
16528 
  """
16529 
 
16530 
  thrift_spec = (
16531 
    None, # 0
16532 
    (1, TType.I64, 'orderId', None, None, ), # 1
16533 
    (2, TType.I64, 'itemId', None, None, ), # 2
16534 
  )
16535 
 
16536 
  def __init__(self, orderId=None, itemId=None,):
16537 
    self.orderId = orderId
16538 
    self.itemId = itemId
16539 
 
16540 
  def read(self, iprot):
16541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16543 
      return
16544 
    iprot.readStructBegin()
16545 
    while True:
16546 
      (fname, ftype, fid) = iprot.readFieldBegin()
16547 
      if ftype == TType.STOP:
16548 
        break
16549 
      if fid == 1:
16550 
        if ftype == TType.I64:
16551 
          self.orderId = iprot.readI64();
16552 
        else:
16553 
          iprot.skip(ftype)
16554 
      elif fid == 2:
16555 
        if ftype == TType.I64:
16556 
          self.itemId = iprot.readI64();
16557 
        else:
16558 
          iprot.skip(ftype)
16559 
      else:
16560 
        iprot.skip(ftype)
16561 
      iprot.readFieldEnd()
16562 
    iprot.readStructEnd()
16563 
 
16564 
  def write(self, oprot):
16565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16567 
      return
16568 
    oprot.writeStructBegin('changeItem_args')
16569 
    if self.orderId is not None:
16570 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16571 
      oprot.writeI64(self.orderId)
16572 
      oprot.writeFieldEnd()
16573 
    if self.itemId is not None:
16574 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16575 
      oprot.writeI64(self.itemId)
16576 
      oprot.writeFieldEnd()
16577 
    oprot.writeFieldStop()
16578 
    oprot.writeStructEnd()
16579 
 
16580 
  def validate(self):
16581 
    return
16582 
 
16583 
 
16584 
  def __repr__(self):
16585 
    L = ['%s=%r' % (key, value)
16586 
      for key, value in self.__dict__.iteritems()]
16587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16588 
 
16589 
  def __eq__(self, other):
16590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16591 
 
16592 
  def __ne__(self, other):
16593 
    return not (self == other)
16594 
 
16595 
class changeItem_result:
16596 
  """
16597 
  Attributes:
16598 
   - success
16599 
   - ex
16600 
  """
16601 
 
16602 
  thrift_spec = (
16603 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16604 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16605 
  )
16606 
 
16607 
  def __init__(self, success=None, ex=None,):
16608 
    self.success = success
16609 
    self.ex = ex
16610 
 
16611 
  def read(self, iprot):
16612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16614 
      return
16615 
    iprot.readStructBegin()
16616 
    while True:
16617 
      (fname, ftype, fid) = iprot.readFieldBegin()
16618 
      if ftype == TType.STOP:
16619 
        break
16620 
      if fid == 0:
16621 
        if ftype == TType.STRUCT:
16622 
          self.success = Order()
16623 
          self.success.read(iprot)
16624 
        else:
16625 
          iprot.skip(ftype)
16626 
      elif fid == 1:
16627 
        if ftype == TType.STRUCT:
16628 
          self.ex = TransactionServiceException()
16629 
          self.ex.read(iprot)
16630 
        else:
16631 
          iprot.skip(ftype)
16632 
      else:
16633 
        iprot.skip(ftype)
16634 
      iprot.readFieldEnd()
16635 
    iprot.readStructEnd()
16636 
 
16637 
  def write(self, oprot):
16638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16640 
      return
16641 
    oprot.writeStructBegin('changeItem_result')
16642 
    if self.success is not None:
16643 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16644 
      self.success.write(oprot)
16645 
      oprot.writeFieldEnd()
16646 
    if self.ex is not None:
16647 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16648 
      self.ex.write(oprot)
16649 
      oprot.writeFieldEnd()
16650 
    oprot.writeFieldStop()
16651 
    oprot.writeStructEnd()
16652 
 
16653 
  def validate(self):
16654 
    return
16655 
 
16656 
 
16657 
  def __repr__(self):
16658 
    L = ['%s=%r' % (key, value)
16659 
      for key, value in self.__dict__.iteritems()]
16660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16661 
 
16662 
  def __eq__(self, other):
16663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16664 
 
16665 
  def __ne__(self, other):
16666 
    return not (self == other)
16667 
 
16668 
class shiftToWarehouse_args:
16669 
  """
16670 
  Attributes:
16671 
   - orderId
16672 
   - warehouseId
16673 
  """
16674 
 
16675 
  thrift_spec = (
16676 
    None, # 0
16677 
    (1, TType.I64, 'orderId', None, None, ), # 1
16678 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
16679 
  )
16680 
 
16681 
  def __init__(self, orderId=None, warehouseId=None,):
16682 
    self.orderId = orderId
16683 
    self.warehouseId = warehouseId
16684 
 
16685 
  def read(self, iprot):
16686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16688 
      return
16689 
    iprot.readStructBegin()
16690 
    while True:
16691 
      (fname, ftype, fid) = iprot.readFieldBegin()
16692 
      if ftype == TType.STOP:
16693 
        break
16694 
      if fid == 1:
16695 
        if ftype == TType.I64:
16696 
          self.orderId = iprot.readI64();
16697 
        else:
16698 
          iprot.skip(ftype)
16699 
      elif fid == 2:
16700 
        if ftype == TType.I64:
16701 
          self.warehouseId = iprot.readI64();
16702 
        else:
16703 
          iprot.skip(ftype)
16704 
      else:
16705 
        iprot.skip(ftype)
16706 
      iprot.readFieldEnd()
16707 
    iprot.readStructEnd()
16708 
 
16709 
  def write(self, oprot):
16710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16712 
      return
16713 
    oprot.writeStructBegin('shiftToWarehouse_args')
16714 
    if self.orderId is not None:
16715 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16716 
      oprot.writeI64(self.orderId)
16717 
      oprot.writeFieldEnd()
16718 
    if self.warehouseId is not None:
16719 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16720 
      oprot.writeI64(self.warehouseId)
16721 
      oprot.writeFieldEnd()
16722 
    oprot.writeFieldStop()
16723 
    oprot.writeStructEnd()
16724 
 
16725 
  def validate(self):
16726 
    return
16727 
 
16728 
 
16729 
  def __repr__(self):
16730 
    L = ['%s=%r' % (key, value)
16731 
      for key, value in self.__dict__.iteritems()]
16732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16733 
 
16734 
  def __eq__(self, other):
16735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16736 
 
16737 
  def __ne__(self, other):
16738 
    return not (self == other)
16739 
 
16740 
class shiftToWarehouse_result:
16741 
  """
16742 
  Attributes:
16743 
   - success
16744 
   - ex
16745 
  """
16746 
 
16747 
  thrift_spec = (
16748 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16749 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16750 
  )
16751 
 
16752 
  def __init__(self, success=None, ex=None,):
16753 
    self.success = success
16754 
    self.ex = ex
16755 
 
16756 
  def read(self, iprot):
16757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16759 
      return
16760 
    iprot.readStructBegin()
16761 
    while True:
16762 
      (fname, ftype, fid) = iprot.readFieldBegin()
16763 
      if ftype == TType.STOP:
16764 
        break
16765 
      if fid == 0:
16766 
        if ftype == TType.STRUCT:
16767 
          self.success = Order()
16768 
          self.success.read(iprot)
16769 
        else:
16770 
          iprot.skip(ftype)
16771 
      elif fid == 1:
16772 
        if ftype == TType.STRUCT:
16773 
          self.ex = TransactionServiceException()
16774 
          self.ex.read(iprot)
16775 
        else:
16776 
          iprot.skip(ftype)
16777 
      else:
16778 
        iprot.skip(ftype)
16779 
      iprot.readFieldEnd()
16780 
    iprot.readStructEnd()
16781 
 
16782 
  def write(self, oprot):
16783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16785 
      return
16786 
    oprot.writeStructBegin('shiftToWarehouse_result')
16787 
    if self.success is not None:
16788 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16789 
      self.success.write(oprot)
16790 
      oprot.writeFieldEnd()
16791 
    if self.ex is not None:
16792 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16793 
      self.ex.write(oprot)
16794 
      oprot.writeFieldEnd()
16795 
    oprot.writeFieldStop()
16796 
    oprot.writeStructEnd()
16797 
 
16798 
  def validate(self):
16799 
    return
16800 
 
16801 
 
16802 
  def __repr__(self):
16803 
    L = ['%s=%r' % (key, value)
16804 
      for key, value in self.__dict__.iteritems()]
16805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16806 
 
16807 
  def __eq__(self, other):
16808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16809 
 
16810 
  def __ne__(self, other):
16811 
    return not (self == other)
3553 chandransh 16812 
 
16813 
class addDelayReason_args:
16814 
  """
16815 
  Attributes:
16816 
   - orderId
16817 
   - delayReason
3986 chandransh 16818 
   - furtherDelay
4647 rajveer 16819 
   - delayReasonText
3553 chandransh 16820 
  """
16821 
 
16822 
  thrift_spec = (
16823 
    None, # 0
16824 
    (1, TType.I64, 'orderId', None, None, ), # 1
16825 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 16826 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 16827 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 16828 
  )
16829 
 
4647 rajveer 16830 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 16831 
    self.orderId = orderId
16832 
    self.delayReason = delayReason
3986 chandransh 16833 
    self.furtherDelay = furtherDelay
4647 rajveer 16834 
    self.delayReasonText = delayReasonText
3553 chandransh 16835 
 
16836 
  def read(self, iprot):
16837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16839 
      return
16840 
    iprot.readStructBegin()
16841 
    while True:
16842 
      (fname, ftype, fid) = iprot.readFieldBegin()
16843 
      if ftype == TType.STOP:
16844 
        break
16845 
      if fid == 1:
16846 
        if ftype == TType.I64:
16847 
          self.orderId = iprot.readI64();
16848 
        else:
16849 
          iprot.skip(ftype)
16850 
      elif fid == 2:
16851 
        if ftype == TType.I32:
16852 
          self.delayReason = iprot.readI32();
16853 
        else:
16854 
          iprot.skip(ftype)
3986 chandransh 16855 
      elif fid == 3:
16856 
        if ftype == TType.I64:
16857 
          self.furtherDelay = iprot.readI64();
16858 
        else:
16859 
          iprot.skip(ftype)
4647 rajveer 16860 
      elif fid == 4:
16861 
        if ftype == TType.STRING:
16862 
          self.delayReasonText = iprot.readString();
16863 
        else:
16864 
          iprot.skip(ftype)
3553 chandransh 16865 
      else:
16866 
        iprot.skip(ftype)
16867 
      iprot.readFieldEnd()
16868 
    iprot.readStructEnd()
16869 
 
16870 
  def write(self, oprot):
16871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16873 
      return
16874 
    oprot.writeStructBegin('addDelayReason_args')
16875 
    if self.orderId is not None:
16876 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16877 
      oprot.writeI64(self.orderId)
16878 
      oprot.writeFieldEnd()
16879 
    if self.delayReason is not None:
16880 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
16881 
      oprot.writeI32(self.delayReason)
16882 
      oprot.writeFieldEnd()
3986 chandransh 16883 
    if self.furtherDelay is not None:
16884 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
16885 
      oprot.writeI64(self.furtherDelay)
16886 
      oprot.writeFieldEnd()
4647 rajveer 16887 
    if self.delayReasonText is not None:
16888 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
16889 
      oprot.writeString(self.delayReasonText)
16890 
      oprot.writeFieldEnd()
3553 chandransh 16891 
    oprot.writeFieldStop()
16892 
    oprot.writeStructEnd()
16893 
 
16894 
  def validate(self):
16895 
    return
16896 
 
16897 
 
16898 
  def __repr__(self):
16899 
    L = ['%s=%r' % (key, value)
16900 
      for key, value in self.__dict__.iteritems()]
16901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16902 
 
16903 
  def __eq__(self, other):
16904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16905 
 
16906 
  def __ne__(self, other):
16907 
    return not (self == other)
16908 
 
16909 
class addDelayReason_result:
16910 
  """
16911 
  Attributes:
16912 
   - success
16913 
   - ex
16914 
  """
16915 
 
16916 
  thrift_spec = (
16917 
    (0, TType.BOOL, 'success', None, None, ), # 0
16918 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16919 
  )
16920 
 
16921 
  def __init__(self, success=None, ex=None,):
16922 
    self.success = success
16923 
    self.ex = ex
16924 
 
16925 
  def read(self, iprot):
16926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16928 
      return
16929 
    iprot.readStructBegin()
16930 
    while True:
16931 
      (fname, ftype, fid) = iprot.readFieldBegin()
16932 
      if ftype == TType.STOP:
16933 
        break
16934 
      if fid == 0:
16935 
        if ftype == TType.BOOL:
16936 
          self.success = iprot.readBool();
16937 
        else:
16938 
          iprot.skip(ftype)
16939 
      elif fid == 1:
16940 
        if ftype == TType.STRUCT:
16941 
          self.ex = TransactionServiceException()
16942 
          self.ex.read(iprot)
16943 
        else:
16944 
          iprot.skip(ftype)
16945 
      else:
16946 
        iprot.skip(ftype)
16947 
      iprot.readFieldEnd()
16948 
    iprot.readStructEnd()
16949 
 
16950 
  def write(self, oprot):
16951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16953 
      return
16954 
    oprot.writeStructBegin('addDelayReason_result')
16955 
    if self.success is not None:
16956 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16957 
      oprot.writeBool(self.success)
16958 
      oprot.writeFieldEnd()
16959 
    if self.ex is not None:
16960 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16961 
      self.ex.write(oprot)
16962 
      oprot.writeFieldEnd()
16963 
    oprot.writeFieldStop()
16964 
    oprot.writeStructEnd()
16965 
 
16966 
  def validate(self):
16967 
    return
16968 
 
16969 
 
16970 
  def __repr__(self):
16971 
    L = ['%s=%r' % (key, value)
16972 
      for key, value in self.__dict__.iteritems()]
16973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16974 
 
16975 
  def __eq__(self, other):
16976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16977 
 
16978 
  def __ne__(self, other):
16979 
    return not (self == other)
3956 chandransh 16980 
 
16981 
class reconcileCodCollection_args:
16982 
  """
16983 
  Attributes:
16984 
   - collectedAmountMap
16985 
   - xferBy
16986 
   - xferTxnId
16987 
   - xferDate
16988 
  """
16989 
 
16990 
  thrift_spec = (
16991 
    None, # 0
16992 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
16993 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
16994 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
16995 
    (4, TType.I64, 'xferDate', None, None, ), # 4
16996 
  )
16997 
 
16998 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
16999 
    self.collectedAmountMap = collectedAmountMap
17000 
    self.xferBy = xferBy
17001 
    self.xferTxnId = xferTxnId
17002 
    self.xferDate = xferDate
17003 
 
17004 
  def read(self, iprot):
17005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17007 
      return
17008 
    iprot.readStructBegin()
17009 
    while True:
17010 
      (fname, ftype, fid) = iprot.readFieldBegin()
17011 
      if ftype == TType.STOP:
17012 
        break
17013 
      if fid == 1:
17014 
        if ftype == TType.MAP:
17015 
          self.collectedAmountMap = {}
5031 varun.gupt 17016 
          (_ktype362, _vtype363, _size361 ) = iprot.readMapBegin()
17017 
          for _i365 in xrange(_size361):
17018 
            _key366 = iprot.readString();
17019 
            _val367 = iprot.readDouble();
17020 
            self.collectedAmountMap[_key366] = _val367
3956 chandransh 17021 
          iprot.readMapEnd()
17022 
        else:
17023 
          iprot.skip(ftype)
17024 
      elif fid == 2:
17025 
        if ftype == TType.STRING:
17026 
          self.xferBy = iprot.readString();
17027 
        else:
17028 
          iprot.skip(ftype)
17029 
      elif fid == 3:
17030 
        if ftype == TType.STRING:
17031 
          self.xferTxnId = iprot.readString();
17032 
        else:
17033 
          iprot.skip(ftype)
17034 
      elif fid == 4:
17035 
        if ftype == TType.I64:
17036 
          self.xferDate = iprot.readI64();
17037 
        else:
17038 
          iprot.skip(ftype)
17039 
      else:
17040 
        iprot.skip(ftype)
17041 
      iprot.readFieldEnd()
17042 
    iprot.readStructEnd()
17043 
 
17044 
  def write(self, oprot):
17045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17047 
      return
17048 
    oprot.writeStructBegin('reconcileCodCollection_args')
17049 
    if self.collectedAmountMap is not None:
17050 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
17051 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
5031 varun.gupt 17052 
      for kiter368,viter369 in self.collectedAmountMap.items():
17053 
        oprot.writeString(kiter368)
17054 
        oprot.writeDouble(viter369)
3956 chandransh 17055 
      oprot.writeMapEnd()
17056 
      oprot.writeFieldEnd()
17057 
    if self.xferBy is not None:
17058 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
17059 
      oprot.writeString(self.xferBy)
17060 
      oprot.writeFieldEnd()
17061 
    if self.xferTxnId is not None:
17062 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
17063 
      oprot.writeString(self.xferTxnId)
17064 
      oprot.writeFieldEnd()
17065 
    if self.xferDate is not None:
17066 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
17067 
      oprot.writeI64(self.xferDate)
17068 
      oprot.writeFieldEnd()
17069 
    oprot.writeFieldStop()
17070 
    oprot.writeStructEnd()
17071 
 
17072 
  def validate(self):
17073 
    return
17074 
 
17075 
 
17076 
  def __repr__(self):
17077 
    L = ['%s=%r' % (key, value)
17078 
      for key, value in self.__dict__.iteritems()]
17079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17080 
 
17081 
  def __eq__(self, other):
17082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17083 
 
17084 
  def __ne__(self, other):
17085 
    return not (self == other)
17086 
 
17087 
class reconcileCodCollection_result:
17088 
  """
17089 
  Attributes:
17090 
   - success
17091 
   - ex
17092 
  """
17093 
 
17094 
  thrift_spec = (
17095 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
17096 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17097 
  )
17098 
 
17099 
  def __init__(self, success=None, ex=None,):
17100 
    self.success = success
17101 
    self.ex = ex
17102 
 
17103 
  def read(self, iprot):
17104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17106 
      return
17107 
    iprot.readStructBegin()
17108 
    while True:
17109 
      (fname, ftype, fid) = iprot.readFieldBegin()
17110 
      if ftype == TType.STOP:
17111 
        break
17112 
      if fid == 0:
17113 
        if ftype == TType.MAP:
17114 
          self.success = {}
5031 varun.gupt 17115 
          (_ktype371, _vtype372, _size370 ) = iprot.readMapBegin()
17116 
          for _i374 in xrange(_size370):
17117 
            _key375 = iprot.readString();
17118 
            _val376 = iprot.readString();
17119 
            self.success[_key375] = _val376
3956 chandransh 17120 
          iprot.readMapEnd()
17121 
        else:
17122 
          iprot.skip(ftype)
17123 
      elif fid == 1:
17124 
        if ftype == TType.STRUCT:
17125 
          self.ex = TransactionServiceException()
17126 
          self.ex.read(iprot)
17127 
        else:
17128 
          iprot.skip(ftype)
17129 
      else:
17130 
        iprot.skip(ftype)
17131 
      iprot.readFieldEnd()
17132 
    iprot.readStructEnd()
17133 
 
17134 
  def write(self, oprot):
17135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17137 
      return
17138 
    oprot.writeStructBegin('reconcileCodCollection_result')
17139 
    if self.success is not None:
17140 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17141 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
5031 varun.gupt 17142 
      for kiter377,viter378 in self.success.items():
17143 
        oprot.writeString(kiter377)
17144 
        oprot.writeString(viter378)
3956 chandransh 17145 
      oprot.writeMapEnd()
17146 
      oprot.writeFieldEnd()
17147 
    if self.ex is not None:
17148 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17149 
      self.ex.write(oprot)
17150 
      oprot.writeFieldEnd()
17151 
    oprot.writeFieldStop()
17152 
    oprot.writeStructEnd()
17153 
 
17154 
  def validate(self):
17155 
    return
17156 
 
17157 
 
17158 
  def __repr__(self):
17159 
    L = ['%s=%r' % (key, value)
17160 
      for key, value in self.__dict__.iteritems()]
17161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17162 
 
17163 
  def __eq__(self, other):
17164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17165 
 
17166 
  def __ne__(self, other):
17167 
    return not (self == other)
4008 mandeep.dh 17168 
 
17169 
class getTransactionsRequiringExtraProcessing_args:
17170 
  """
17171 
  Attributes:
17172 
   - category
17173 
  """
17174 
 
17175 
  thrift_spec = (
17176 
    None, # 0
17177 
    (1, TType.I32, 'category', None, None, ), # 1
17178 
  )
17179 
 
17180 
  def __init__(self, category=None,):
17181 
    self.category = category
17182 
 
17183 
  def read(self, iprot):
17184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17186 
      return
17187 
    iprot.readStructBegin()
17188 
    while True:
17189 
      (fname, ftype, fid) = iprot.readFieldBegin()
17190 
      if ftype == TType.STOP:
17191 
        break
17192 
      if fid == 1:
17193 
        if ftype == TType.I32:
17194 
          self.category = iprot.readI32();
17195 
        else:
17196 
          iprot.skip(ftype)
17197 
      else:
17198 
        iprot.skip(ftype)
17199 
      iprot.readFieldEnd()
17200 
    iprot.readStructEnd()
17201 
 
17202 
  def write(self, oprot):
17203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17205 
      return
17206 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
17207 
    if self.category is not None:
17208 
      oprot.writeFieldBegin('category', TType.I32, 1)
17209 
      oprot.writeI32(self.category)
17210 
      oprot.writeFieldEnd()
17211 
    oprot.writeFieldStop()
17212 
    oprot.writeStructEnd()
17213 
 
17214 
  def validate(self):
17215 
    return
17216 
 
17217 
 
17218 
  def __repr__(self):
17219 
    L = ['%s=%r' % (key, value)
17220 
      for key, value in self.__dict__.iteritems()]
17221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17222 
 
17223 
  def __eq__(self, other):
17224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17225 
 
17226 
  def __ne__(self, other):
17227 
    return not (self == other)
17228 
 
17229 
class getTransactionsRequiringExtraProcessing_result:
17230 
  """
17231 
  Attributes:
17232 
   - success
17233 
  """
17234 
 
17235 
  thrift_spec = (
17236 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
17237 
  )
17238 
 
17239 
  def __init__(self, success=None,):
17240 
    self.success = success
17241 
 
17242 
  def read(self, iprot):
17243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17245 
      return
17246 
    iprot.readStructBegin()
17247 
    while True:
17248 
      (fname, ftype, fid) = iprot.readFieldBegin()
17249 
      if ftype == TType.STOP:
17250 
        break
17251 
      if fid == 0:
17252 
        if ftype == TType.LIST:
17253 
          self.success = []
5031 varun.gupt 17254 
          (_etype382, _size379) = iprot.readListBegin()
17255 
          for _i383 in xrange(_size379):
17256 
            _elem384 = iprot.readI64();
17257 
            self.success.append(_elem384)
4008 mandeep.dh 17258 
          iprot.readListEnd()
17259 
        else:
17260 
          iprot.skip(ftype)
17261 
      else:
17262 
        iprot.skip(ftype)
17263 
      iprot.readFieldEnd()
17264 
    iprot.readStructEnd()
17265 
 
17266 
  def write(self, oprot):
17267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17269 
      return
17270 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
17271 
    if self.success is not None:
17272 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17273 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 17274 
      for iter385 in self.success:
17275 
        oprot.writeI64(iter385)
4008 mandeep.dh 17276 
      oprot.writeListEnd()
17277 
      oprot.writeFieldEnd()
17278 
    oprot.writeFieldStop()
17279 
    oprot.writeStructEnd()
17280 
 
17281 
  def validate(self):
17282 
    return
17283 
 
17284 
 
17285 
  def __repr__(self):
17286 
    L = ['%s=%r' % (key, value)
17287 
      for key, value in self.__dict__.iteritems()]
17288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17289 
 
17290 
  def __eq__(self, other):
17291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17292 
 
17293 
  def __ne__(self, other):
17294 
    return not (self == other)
17295 
 
17296 
class markTransactionAsProcessed_args:
17297 
  """
17298 
  Attributes:
17299 
   - transactionId
17300 
   - category
17301 
  """
17302 
 
17303 
  thrift_spec = (
17304 
    None, # 0
17305 
    (1, TType.I64, 'transactionId', None, None, ), # 1
17306 
    (2, TType.I32, 'category', None, None, ), # 2
17307 
  )
17308 
 
17309 
  def __init__(self, transactionId=None, category=None,):
17310 
    self.transactionId = transactionId
17311 
    self.category = category
17312 
 
17313 
  def read(self, iprot):
17314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17316 
      return
17317 
    iprot.readStructBegin()
17318 
    while True:
17319 
      (fname, ftype, fid) = iprot.readFieldBegin()
17320 
      if ftype == TType.STOP:
17321 
        break
17322 
      if fid == 1:
17323 
        if ftype == TType.I64:
17324 
          self.transactionId = iprot.readI64();
17325 
        else:
17326 
          iprot.skip(ftype)
17327 
      elif fid == 2:
17328 
        if ftype == TType.I32:
17329 
          self.category = iprot.readI32();
17330 
        else:
17331 
          iprot.skip(ftype)
17332 
      else:
17333 
        iprot.skip(ftype)
17334 
      iprot.readFieldEnd()
17335 
    iprot.readStructEnd()
17336 
 
17337 
  def write(self, oprot):
17338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17340 
      return
17341 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
17342 
    if self.transactionId is not None:
17343 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
17344 
      oprot.writeI64(self.transactionId)
17345 
      oprot.writeFieldEnd()
17346 
    if self.category is not None:
17347 
      oprot.writeFieldBegin('category', TType.I32, 2)
17348 
      oprot.writeI32(self.category)
17349 
      oprot.writeFieldEnd()
17350 
    oprot.writeFieldStop()
17351 
    oprot.writeStructEnd()
17352 
 
17353 
  def validate(self):
17354 
    return
17355 
 
17356 
 
17357 
  def __repr__(self):
17358 
    L = ['%s=%r' % (key, value)
17359 
      for key, value in self.__dict__.iteritems()]
17360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17361 
 
17362 
  def __eq__(self, other):
17363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17364 
 
17365 
  def __ne__(self, other):
17366 
    return not (self == other)
17367 
 
17368 
class markTransactionAsProcessed_result:
17369 
 
17370 
  thrift_spec = (
17371 
  )
17372 
 
17373 
  def read(self, iprot):
17374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17376 
      return
17377 
    iprot.readStructBegin()
17378 
    while True:
17379 
      (fname, ftype, fid) = iprot.readFieldBegin()
17380 
      if ftype == TType.STOP:
17381 
        break
17382 
      else:
17383 
        iprot.skip(ftype)
17384 
      iprot.readFieldEnd()
17385 
    iprot.readStructEnd()
17386 
 
17387 
  def write(self, oprot):
17388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17390 
      return
17391 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
17392 
    oprot.writeFieldStop()
17393 
    oprot.writeStructEnd()
17394 
 
17395 
  def validate(self):
17396 
    return
17397 
 
17398 
 
17399 
  def __repr__(self):
17400 
    L = ['%s=%r' % (key, value)
17401 
      for key, value in self.__dict__.iteritems()]
17402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17403 
 
17404 
  def __eq__(self, other):
17405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17406 
 
17407 
  def __ne__(self, other):
17408 
    return not (self == other)
4018 chandransh 17409 
 
17410 
class getItemWiseRiskyOrdersCount_args:
17411 
 
17412 
  thrift_spec = (
17413 
  )
17414 
 
17415 
  def read(self, iprot):
17416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17418 
      return
17419 
    iprot.readStructBegin()
17420 
    while True:
17421 
      (fname, ftype, fid) = iprot.readFieldBegin()
17422 
      if ftype == TType.STOP:
17423 
        break
17424 
      else:
17425 
        iprot.skip(ftype)
17426 
      iprot.readFieldEnd()
17427 
    iprot.readStructEnd()
17428 
 
17429 
  def write(self, oprot):
17430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17432 
      return
17433 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
17434 
    oprot.writeFieldStop()
17435 
    oprot.writeStructEnd()
17436 
 
17437 
  def validate(self):
17438 
    return
17439 
 
17440 
 
17441 
  def __repr__(self):
17442 
    L = ['%s=%r' % (key, value)
17443 
      for key, value in self.__dict__.iteritems()]
17444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17445 
 
17446 
  def __eq__(self, other):
17447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17448 
 
17449 
  def __ne__(self, other):
17450 
    return not (self == other)
17451 
 
17452 
class getItemWiseRiskyOrdersCount_result:
17453 
  """
17454 
  Attributes:
17455 
   - success
17456 
  """
17457 
 
17458 
  thrift_spec = (
17459 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
17460 
  )
17461 
 
17462 
  def __init__(self, success=None,):
17463 
    self.success = success
17464 
 
17465 
  def read(self, iprot):
17466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17468 
      return
17469 
    iprot.readStructBegin()
17470 
    while True:
17471 
      (fname, ftype, fid) = iprot.readFieldBegin()
17472 
      if ftype == TType.STOP:
17473 
        break
17474 
      if fid == 0:
17475 
        if ftype == TType.MAP:
17476 
          self.success = {}
5031 varun.gupt 17477 
          (_ktype387, _vtype388, _size386 ) = iprot.readMapBegin()
17478 
          for _i390 in xrange(_size386):
17479 
            _key391 = iprot.readI64();
17480 
            _val392 = iprot.readI64();
17481 
            self.success[_key391] = _val392
4018 chandransh 17482 
          iprot.readMapEnd()
17483 
        else:
17484 
          iprot.skip(ftype)
17485 
      else:
17486 
        iprot.skip(ftype)
17487 
      iprot.readFieldEnd()
17488 
    iprot.readStructEnd()
17489 
 
17490 
  def write(self, oprot):
17491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17493 
      return
17494 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
17495 
    if self.success is not None:
17496 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17497 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5031 varun.gupt 17498 
      for kiter393,viter394 in self.success.items():
17499 
        oprot.writeI64(kiter393)
17500 
        oprot.writeI64(viter394)
4018 chandransh 17501 
      oprot.writeMapEnd()
17502 
      oprot.writeFieldEnd()
17503 
    oprot.writeFieldStop()
17504 
    oprot.writeStructEnd()
17505 
 
17506 
  def validate(self):
17507 
    return
17508 
 
17509 
 
17510 
  def __repr__(self):
17511 
    L = ['%s=%r' % (key, value)
17512 
      for key, value in self.__dict__.iteritems()]
17513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17514 
 
17515 
  def __eq__(self, other):
17516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17517 
 
17518 
  def __ne__(self, other):
17519 
    return not (self == other)
4247 rajveer 17520 
 
4295 varun.gupt 17521 
class getOrdersForItemIds_args:
17522 
  """
17523 
  Attributes:
17524 
   - itemIds
17525 
  """
17526 
 
17527 
  thrift_spec = (
17528 
    None, # 0
17529 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
17530 
  )
17531 
 
17532 
  def __init__(self, itemIds=None,):
17533 
    self.itemIds = itemIds
17534 
 
17535 
  def read(self, iprot):
17536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17538 
      return
17539 
    iprot.readStructBegin()
17540 
    while True:
17541 
      (fname, ftype, fid) = iprot.readFieldBegin()
17542 
      if ftype == TType.STOP:
17543 
        break
17544 
      if fid == 1:
17545 
        if ftype == TType.LIST:
17546 
          self.itemIds = []
5031 varun.gupt 17547 
          (_etype398, _size395) = iprot.readListBegin()
17548 
          for _i399 in xrange(_size395):
17549 
            _elem400 = iprot.readI64();
17550 
            self.itemIds.append(_elem400)
4295 varun.gupt 17551 
          iprot.readListEnd()
17552 
        else:
17553 
          iprot.skip(ftype)
17554 
      else:
17555 
        iprot.skip(ftype)
17556 
      iprot.readFieldEnd()
17557 
    iprot.readStructEnd()
17558 
 
17559 
  def write(self, oprot):
17560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17562 
      return
17563 
    oprot.writeStructBegin('getOrdersForItemIds_args')
17564 
    if self.itemIds is not None:
17565 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
17566 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5031 varun.gupt 17567 
      for iter401 in self.itemIds:
17568 
        oprot.writeI64(iter401)
4295 varun.gupt 17569 
      oprot.writeListEnd()
17570 
      oprot.writeFieldEnd()
17571 
    oprot.writeFieldStop()
17572 
    oprot.writeStructEnd()
17573 
 
17574 
  def validate(self):
17575 
    return
17576 
 
17577 
 
17578 
  def __repr__(self):
17579 
    L = ['%s=%r' % (key, value)
17580 
      for key, value in self.__dict__.iteritems()]
17581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17582 
 
17583 
  def __eq__(self, other):
17584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17585 
 
17586 
  def __ne__(self, other):
17587 
    return not (self == other)
17588 
 
17589 
class getOrdersForItemIds_result:
17590 
  """
17591 
  Attributes:
17592 
   - success
17593 
  """
17594 
 
17595 
  thrift_spec = (
17596 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17597 
  )
17598 
 
17599 
  def __init__(self, success=None,):
17600 
    self.success = success
17601 
 
17602 
  def read(self, iprot):
17603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17605 
      return
17606 
    iprot.readStructBegin()
17607 
    while True:
17608 
      (fname, ftype, fid) = iprot.readFieldBegin()
17609 
      if ftype == TType.STOP:
17610 
        break
17611 
      if fid == 0:
17612 
        if ftype == TType.LIST:
17613 
          self.success = []
5031 varun.gupt 17614 
          (_etype405, _size402) = iprot.readListBegin()
17615 
          for _i406 in xrange(_size402):
17616 
            _elem407 = Order()
17617 
            _elem407.read(iprot)
17618 
            self.success.append(_elem407)
4295 varun.gupt 17619 
          iprot.readListEnd()
17620 
        else:
17621 
          iprot.skip(ftype)
17622 
      else:
17623 
        iprot.skip(ftype)
17624 
      iprot.readFieldEnd()
17625 
    iprot.readStructEnd()
17626 
 
17627 
  def write(self, oprot):
17628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17630 
      return
17631 
    oprot.writeStructBegin('getOrdersForItemIds_result')
17632 
    if self.success is not None:
17633 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17634 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 17635 
      for iter408 in self.success:
17636 
        iter408.write(oprot)
4295 varun.gupt 17637 
      oprot.writeListEnd()
17638 
      oprot.writeFieldEnd()
17639 
    oprot.writeFieldStop()
17640 
    oprot.writeStructEnd()
17641 
 
17642 
  def validate(self):
17643 
    return
17644 
 
17645 
 
17646 
  def __repr__(self):
17647 
    L = ['%s=%r' % (key, value)
17648 
      for key, value in self.__dict__.iteritems()]
17649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17650 
 
17651 
  def __eq__(self, other):
17652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17653 
 
17654 
  def __ne__(self, other):
17655 
    return not (self == other)
17656 
 
4247 rajveer 17657 
class markOrderCancellationRequestReceived_args:
17658 
  """
17659 
  Attributes:
17660 
   - orderId
17661 
  """
17662 
 
17663 
  thrift_spec = (
17664 
    None, # 0
17665 
    (1, TType.I64, 'orderId', None, None, ), # 1
17666 
  )
17667 
 
17668 
  def __init__(self, orderId=None,):
17669 
    self.orderId = orderId
17670 
 
17671 
  def read(self, iprot):
17672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17674 
      return
17675 
    iprot.readStructBegin()
17676 
    while True:
17677 
      (fname, ftype, fid) = iprot.readFieldBegin()
17678 
      if ftype == TType.STOP:
17679 
        break
17680 
      if fid == 1:
17681 
        if ftype == TType.I64:
17682 
          self.orderId = iprot.readI64();
17683 
        else:
17684 
          iprot.skip(ftype)
17685 
      else:
17686 
        iprot.skip(ftype)
17687 
      iprot.readFieldEnd()
17688 
    iprot.readStructEnd()
17689 
 
17690 
  def write(self, oprot):
17691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17693 
      return
17694 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
17695 
    if self.orderId is not None:
17696 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17697 
      oprot.writeI64(self.orderId)
17698 
      oprot.writeFieldEnd()
17699 
    oprot.writeFieldStop()
17700 
    oprot.writeStructEnd()
17701 
 
17702 
  def validate(self):
17703 
    return
17704 
 
17705 
 
17706 
  def __repr__(self):
17707 
    L = ['%s=%r' % (key, value)
17708 
      for key, value in self.__dict__.iteritems()]
17709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17710 
 
17711 
  def __eq__(self, other):
17712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17713 
 
17714 
  def __ne__(self, other):
17715 
    return not (self == other)
17716 
 
17717 
class markOrderCancellationRequestReceived_result:
17718 
  """
17719 
  Attributes:
17720 
   - ex
17721 
  """
17722 
 
17723 
  thrift_spec = (
17724 
    None, # 0
17725 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17726 
  )
17727 
 
17728 
  def __init__(self, ex=None,):
17729 
    self.ex = ex
17730 
 
17731 
  def read(self, iprot):
17732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17734 
      return
17735 
    iprot.readStructBegin()
17736 
    while True:
17737 
      (fname, ftype, fid) = iprot.readFieldBegin()
17738 
      if ftype == TType.STOP:
17739 
        break
17740 
      if fid == 1:
17741 
        if ftype == TType.STRUCT:
17742 
          self.ex = TransactionServiceException()
17743 
          self.ex.read(iprot)
17744 
        else:
17745 
          iprot.skip(ftype)
17746 
      else:
17747 
        iprot.skip(ftype)
17748 
      iprot.readFieldEnd()
17749 
    iprot.readStructEnd()
17750 
 
17751 
  def write(self, oprot):
17752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17754 
      return
17755 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
17756 
    if self.ex is not None:
17757 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17758 
      self.ex.write(oprot)
17759 
      oprot.writeFieldEnd()
17760 
    oprot.writeFieldStop()
17761 
    oprot.writeStructEnd()
17762 
 
17763 
  def validate(self):
17764 
    return
17765 
 
17766 
 
17767 
  def __repr__(self):
17768 
    L = ['%s=%r' % (key, value)
17769 
      for key, value in self.__dict__.iteritems()]
17770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17771 
 
17772 
  def __eq__(self, other):
17773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17774 
 
17775 
  def __ne__(self, other):
17776 
    return not (self == other)
17777 
 
17778 
class markOrderCancellationRequestConfirmed_args:
17779 
  """
17780 
  Attributes:
17781 
   - orderId
17782 
  """
17783 
 
17784 
  thrift_spec = (
17785 
    None, # 0
17786 
    (1, TType.I64, 'orderId', None, None, ), # 1
17787 
  )
17788 
 
17789 
  def __init__(self, orderId=None,):
17790 
    self.orderId = orderId
17791 
 
17792 
  def read(self, iprot):
17793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17795 
      return
17796 
    iprot.readStructBegin()
17797 
    while True:
17798 
      (fname, ftype, fid) = iprot.readFieldBegin()
17799 
      if ftype == TType.STOP:
17800 
        break
17801 
      if fid == 1:
17802 
        if ftype == TType.I64:
17803 
          self.orderId = iprot.readI64();
17804 
        else:
17805 
          iprot.skip(ftype)
17806 
      else:
17807 
        iprot.skip(ftype)
17808 
      iprot.readFieldEnd()
17809 
    iprot.readStructEnd()
17810 
 
17811 
  def write(self, oprot):
17812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17814 
      return
17815 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
17816 
    if self.orderId is not None:
17817 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17818 
      oprot.writeI64(self.orderId)
17819 
      oprot.writeFieldEnd()
17820 
    oprot.writeFieldStop()
17821 
    oprot.writeStructEnd()
17822 
 
17823 
  def validate(self):
17824 
    return
17825 
 
17826 
 
17827 
  def __repr__(self):
17828 
    L = ['%s=%r' % (key, value)
17829 
      for key, value in self.__dict__.iteritems()]
17830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17831 
 
17832 
  def __eq__(self, other):
17833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17834 
 
17835 
  def __ne__(self, other):
17836 
    return not (self == other)
17837 
 
17838 
class markOrderCancellationRequestConfirmed_result:
17839 
  """
17840 
  Attributes:
17841 
   - ex
17842 
  """
17843 
 
17844 
  thrift_spec = (
17845 
    None, # 0
17846 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17847 
  )
17848 
 
17849 
  def __init__(self, ex=None,):
17850 
    self.ex = ex
17851 
 
17852 
  def read(self, iprot):
17853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17855 
      return
17856 
    iprot.readStructBegin()
17857 
    while True:
17858 
      (fname, ftype, fid) = iprot.readFieldBegin()
17859 
      if ftype == TType.STOP:
17860 
        break
17861 
      if fid == 1:
17862 
        if ftype == TType.STRUCT:
17863 
          self.ex = TransactionServiceException()
17864 
          self.ex.read(iprot)
17865 
        else:
17866 
          iprot.skip(ftype)
17867 
      else:
17868 
        iprot.skip(ftype)
17869 
      iprot.readFieldEnd()
17870 
    iprot.readStructEnd()
17871 
 
17872 
  def write(self, oprot):
17873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17875 
      return
17876 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
17877 
    if self.ex is not None:
17878 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17879 
      self.ex.write(oprot)
17880 
      oprot.writeFieldEnd()
17881 
    oprot.writeFieldStop()
17882 
    oprot.writeStructEnd()
17883 
 
17884 
  def validate(self):
17885 
    return
17886 
 
17887 
 
17888 
  def __repr__(self):
17889 
    L = ['%s=%r' % (key, value)
17890 
      for key, value in self.__dict__.iteritems()]
17891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17892 
 
17893 
  def __eq__(self, other):
17894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17895 
 
17896 
  def __ne__(self, other):
17897 
    return not (self == other)
17898 
 
17899 
class markOrderCancellationRequestDenied_args:
17900 
  """
17901 
  Attributes:
17902 
   - orderId
17903 
  """
17904 
 
17905 
  thrift_spec = (
17906 
    None, # 0
17907 
    (1, TType.I64, 'orderId', None, None, ), # 1
17908 
  )
17909 
 
17910 
  def __init__(self, orderId=None,):
17911 
    self.orderId = orderId
17912 
 
17913 
  def read(self, iprot):
17914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17916 
      return
17917 
    iprot.readStructBegin()
17918 
    while True:
17919 
      (fname, ftype, fid) = iprot.readFieldBegin()
17920 
      if ftype == TType.STOP:
17921 
        break
17922 
      if fid == 1:
17923 
        if ftype == TType.I64:
17924 
          self.orderId = iprot.readI64();
17925 
        else:
17926 
          iprot.skip(ftype)
17927 
      else:
17928 
        iprot.skip(ftype)
17929 
      iprot.readFieldEnd()
17930 
    iprot.readStructEnd()
17931 
 
17932 
  def write(self, oprot):
17933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17935 
      return
17936 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
17937 
    if self.orderId is not None:
17938 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17939 
      oprot.writeI64(self.orderId)
17940 
      oprot.writeFieldEnd()
17941 
    oprot.writeFieldStop()
17942 
    oprot.writeStructEnd()
17943 
 
17944 
  def validate(self):
17945 
    return
17946 
 
17947 
 
17948 
  def __repr__(self):
17949 
    L = ['%s=%r' % (key, value)
17950 
      for key, value in self.__dict__.iteritems()]
17951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17952 
 
17953 
  def __eq__(self, other):
17954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17955 
 
17956 
  def __ne__(self, other):
17957 
    return not (self == other)
17958 
 
17959 
class markOrderCancellationRequestDenied_result:
17960 
  """
17961 
  Attributes:
17962 
   - ex
17963 
  """
17964 
 
17965 
  thrift_spec = (
17966 
    None, # 0
17967 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17968 
  )
17969 
 
17970 
  def __init__(self, ex=None,):
17971 
    self.ex = ex
17972 
 
17973 
  def read(self, iprot):
17974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17976 
      return
17977 
    iprot.readStructBegin()
17978 
    while True:
17979 
      (fname, ftype, fid) = iprot.readFieldBegin()
17980 
      if ftype == TType.STOP:
17981 
        break
17982 
      if fid == 1:
17983 
        if ftype == TType.STRUCT:
17984 
          self.ex = TransactionServiceException()
17985 
          self.ex.read(iprot)
17986 
        else:
17987 
          iprot.skip(ftype)
17988 
      else:
17989 
        iprot.skip(ftype)
17990 
      iprot.readFieldEnd()
17991 
    iprot.readStructEnd()
17992 
 
17993 
  def write(self, oprot):
17994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17996 
      return
17997 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
17998 
    if self.ex is not None:
17999 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18000 
      self.ex.write(oprot)
18001 
      oprot.writeFieldEnd()
18002 
    oprot.writeFieldStop()
18003 
    oprot.writeStructEnd()
18004 
 
18005 
  def validate(self):
18006 
    return
18007 
 
18008 
 
18009 
  def __repr__(self):
18010 
    L = ['%s=%r' % (key, value)
18011 
      for key, value in self.__dict__.iteritems()]
18012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18013 
 
18014 
  def __eq__(self, other):
18015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18016 
 
18017 
  def __ne__(self, other):
18018 
    return not (self == other)
18019 
 
4258 rajveer 18020 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 18021 
  """
18022 
  Attributes:
4258 rajveer 18023 
   - transactionId
4247 rajveer 18024 
  """
18025 
 
18026 
  thrift_spec = (
18027 
    None, # 0
4258 rajveer 18028 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 18029 
  )
18030 
 
4258 rajveer 18031 
  def __init__(self, transactionId=None,):
18032 
    self.transactionId = transactionId
4247 rajveer 18033 
 
18034 
  def read(self, iprot):
18035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18037 
      return
18038 
    iprot.readStructBegin()
18039 
    while True:
18040 
      (fname, ftype, fid) = iprot.readFieldBegin()
18041 
      if ftype == TType.STOP:
18042 
        break
18043 
      if fid == 1:
18044 
        if ftype == TType.I64:
4258 rajveer 18045 
          self.transactionId = iprot.readI64();
4247 rajveer 18046 
        else:
18047 
          iprot.skip(ftype)
18048 
      else:
18049 
        iprot.skip(ftype)
18050 
      iprot.readFieldEnd()
18051 
    iprot.readStructEnd()
18052 
 
18053 
  def write(self, oprot):
18054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18056 
      return
4258 rajveer 18057 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
18058 
    if self.transactionId is not None:
18059 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18060 
      oprot.writeI64(self.transactionId)
4247 rajveer 18061 
      oprot.writeFieldEnd()
18062 
    oprot.writeFieldStop()
18063 
    oprot.writeStructEnd()
18064 
 
18065 
  def validate(self):
18066 
    return
18067 
 
18068 
 
18069 
  def __repr__(self):
18070 
    L = ['%s=%r' % (key, value)
18071 
      for key, value in self.__dict__.iteritems()]
18072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18073 
 
18074 
  def __eq__(self, other):
18075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18076 
 
18077 
  def __ne__(self, other):
18078 
    return not (self == other)
18079 
 
4258 rajveer 18080 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 18081 
  """
18082 
  Attributes:
18083 
   - ex
18084 
  """
18085 
 
18086 
  thrift_spec = (
18087 
    None, # 0
18088 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18089 
  )
18090 
 
18091 
  def __init__(self, ex=None,):
18092 
    self.ex = ex
18093 
 
18094 
  def read(self, iprot):
18095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18097 
      return
18098 
    iprot.readStructBegin()
18099 
    while True:
18100 
      (fname, ftype, fid) = iprot.readFieldBegin()
18101 
      if ftype == TType.STOP:
18102 
        break
18103 
      if fid == 1:
18104 
        if ftype == TType.STRUCT:
18105 
          self.ex = TransactionServiceException()
18106 
          self.ex.read(iprot)
18107 
        else:
18108 
          iprot.skip(ftype)
18109 
      else:
18110 
        iprot.skip(ftype)
18111 
      iprot.readFieldEnd()
18112 
    iprot.readStructEnd()
18113 
 
18114 
  def write(self, oprot):
18115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18117 
      return
4258 rajveer 18118 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 18119 
    if self.ex is not None:
18120 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18121 
      self.ex.write(oprot)
18122 
      oprot.writeFieldEnd()
18123 
    oprot.writeFieldStop()
18124 
    oprot.writeStructEnd()
18125 
 
18126 
  def validate(self):
18127 
    return
18128 
 
18129 
 
18130 
  def __repr__(self):
18131 
    L = ['%s=%r' % (key, value)
18132 
      for key, value in self.__dict__.iteritems()]
18133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18134 
 
18135 
  def __eq__(self, other):
18136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18137 
 
18138 
  def __ne__(self, other):
18139 
    return not (self == other)
4259 anupam.sin 18140 
 
18141 
class refundTransaction_args:
18142 
  """
18143 
  Attributes:
18144 
   - transactionId
18145 
   - refundedBy
18146 
   - reason
18147 
  """
18148 
 
18149 
  thrift_spec = (
18150 
    None, # 0
18151 
    (1, TType.I64, 'transactionId', None, None, ), # 1
18152 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18153 
    (3, TType.STRING, 'reason', None, None, ), # 3
18154 
  )
18155 
 
18156 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
18157 
    self.transactionId = transactionId
18158 
    self.refundedBy = refundedBy
18159 
    self.reason = reason
18160 
 
18161 
  def read(self, iprot):
18162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18164 
      return
18165 
    iprot.readStructBegin()
18166 
    while True:
18167 
      (fname, ftype, fid) = iprot.readFieldBegin()
18168 
      if ftype == TType.STOP:
18169 
        break
18170 
      if fid == 1:
18171 
        if ftype == TType.I64:
18172 
          self.transactionId = iprot.readI64();
18173 
        else:
18174 
          iprot.skip(ftype)
18175 
      elif fid == 2:
18176 
        if ftype == TType.STRING:
18177 
          self.refundedBy = iprot.readString();
18178 
        else:
18179 
          iprot.skip(ftype)
18180 
      elif fid == 3:
18181 
        if ftype == TType.STRING:
18182 
          self.reason = iprot.readString();
18183 
        else:
18184 
          iprot.skip(ftype)
18185 
      else:
18186 
        iprot.skip(ftype)
18187 
      iprot.readFieldEnd()
18188 
    iprot.readStructEnd()
18189 
 
18190 
  def write(self, oprot):
18191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18193 
      return
18194 
    oprot.writeStructBegin('refundTransaction_args')
18195 
    if self.transactionId is not None:
18196 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18197 
      oprot.writeI64(self.transactionId)
18198 
      oprot.writeFieldEnd()
18199 
    if self.refundedBy is not None:
18200 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18201 
      oprot.writeString(self.refundedBy)
18202 
      oprot.writeFieldEnd()
18203 
    if self.reason is not None:
18204 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18205 
      oprot.writeString(self.reason)
18206 
      oprot.writeFieldEnd()
18207 
    oprot.writeFieldStop()
18208 
    oprot.writeStructEnd()
18209 
 
18210 
  def validate(self):
18211 
    return
18212 
 
18213 
 
18214 
  def __repr__(self):
18215 
    L = ['%s=%r' % (key, value)
18216 
      for key, value in self.__dict__.iteritems()]
18217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18218 
 
18219 
  def __eq__(self, other):
18220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18221 
 
18222 
  def __ne__(self, other):
18223 
    return not (self == other)
18224 
 
18225 
class refundTransaction_result:
18226 
  """
18227 
  Attributes:
18228 
   - ex
18229 
  """
18230 
 
18231 
  thrift_spec = (
18232 
    None, # 0
18233 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18234 
  )
18235 
 
18236 
  def __init__(self, ex=None,):
18237 
    self.ex = ex
18238 
 
18239 
  def read(self, iprot):
18240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18242 
      return
18243 
    iprot.readStructBegin()
18244 
    while True:
18245 
      (fname, ftype, fid) = iprot.readFieldBegin()
18246 
      if ftype == TType.STOP:
18247 
        break
18248 
      if fid == 1:
18249 
        if ftype == TType.STRUCT:
18250 
          self.ex = TransactionServiceException()
18251 
          self.ex.read(iprot)
18252 
        else:
18253 
          iprot.skip(ftype)
18254 
      else:
18255 
        iprot.skip(ftype)
18256 
      iprot.readFieldEnd()
18257 
    iprot.readStructEnd()
18258 
 
18259 
  def write(self, oprot):
18260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18262 
      return
18263 
    oprot.writeStructBegin('refundTransaction_result')
18264 
    if self.ex is not None:
18265 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18266 
      self.ex.write(oprot)
18267 
      oprot.writeFieldEnd()
18268 
    oprot.writeFieldStop()
18269 
    oprot.writeStructEnd()
18270 
 
18271 
  def validate(self):
18272 
    return
18273 
 
18274 
 
18275 
  def __repr__(self):
18276 
    L = ['%s=%r' % (key, value)
18277 
      for key, value in self.__dict__.iteritems()]
18278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18279 
 
18280 
  def __eq__(self, other):
18281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18282 
 
18283 
  def __ne__(self, other):
18284 
    return not (self == other)
4285 rajveer 18285 
 
4324 mandeep.dh 18286 
class updateShipmentAddress_args:
18287 
  """
18288 
  Attributes:
18289 
   - orderId
18290 
   - addressId
18291 
  """
18292 
 
18293 
  thrift_spec = (
18294 
    None, # 0
18295 
    (1, TType.I64, 'orderId', None, None, ), # 1
18296 
    (2, TType.I64, 'addressId', None, None, ), # 2
18297 
  )
18298 
 
18299 
  def __init__(self, orderId=None, addressId=None,):
18300 
    self.orderId = orderId
18301 
    self.addressId = addressId
18302 
 
18303 
  def read(self, iprot):
18304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18306 
      return
18307 
    iprot.readStructBegin()
18308 
    while True:
18309 
      (fname, ftype, fid) = iprot.readFieldBegin()
18310 
      if ftype == TType.STOP:
18311 
        break
18312 
      if fid == 1:
18313 
        if ftype == TType.I64:
18314 
          self.orderId = iprot.readI64();
18315 
        else:
18316 
          iprot.skip(ftype)
18317 
      elif fid == 2:
18318 
        if ftype == TType.I64:
18319 
          self.addressId = iprot.readI64();
18320 
        else:
18321 
          iprot.skip(ftype)
18322 
      else:
18323 
        iprot.skip(ftype)
18324 
      iprot.readFieldEnd()
18325 
    iprot.readStructEnd()
18326 
 
18327 
  def write(self, oprot):
18328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18330 
      return
18331 
    oprot.writeStructBegin('updateShipmentAddress_args')
18332 
    if self.orderId is not None:
18333 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18334 
      oprot.writeI64(self.orderId)
18335 
      oprot.writeFieldEnd()
18336 
    if self.addressId is not None:
18337 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
18338 
      oprot.writeI64(self.addressId)
18339 
      oprot.writeFieldEnd()
18340 
    oprot.writeFieldStop()
18341 
    oprot.writeStructEnd()
18342 
 
18343 
  def validate(self):
18344 
    return
18345 
 
18346 
 
18347 
  def __repr__(self):
18348 
    L = ['%s=%r' % (key, value)
18349 
      for key, value in self.__dict__.iteritems()]
18350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18351 
 
18352 
  def __eq__(self, other):
18353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18354 
 
18355 
  def __ne__(self, other):
18356 
    return not (self == other)
18357 
 
18358 
class updateShipmentAddress_result:
18359 
  """
18360 
  Attributes:
18361 
   - ex
18362 
  """
18363 
 
18364 
  thrift_spec = (
18365 
    None, # 0
18366 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18367 
  )
18368 
 
18369 
  def __init__(self, ex=None,):
18370 
    self.ex = ex
18371 
 
18372 
  def read(self, iprot):
18373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18375 
      return
18376 
    iprot.readStructBegin()
18377 
    while True:
18378 
      (fname, ftype, fid) = iprot.readFieldBegin()
18379 
      if ftype == TType.STOP:
18380 
        break
18381 
      if fid == 1:
18382 
        if ftype == TType.STRUCT:
18383 
          self.ex = TransactionServiceException()
18384 
          self.ex.read(iprot)
18385 
        else:
18386 
          iprot.skip(ftype)
18387 
      else:
18388 
        iprot.skip(ftype)
18389 
      iprot.readFieldEnd()
18390 
    iprot.readStructEnd()
18391 
 
18392 
  def write(self, oprot):
18393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18395 
      return
18396 
    oprot.writeStructBegin('updateShipmentAddress_result')
18397 
    if self.ex is not None:
18398 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18399 
      self.ex.write(oprot)
18400 
      oprot.writeFieldEnd()
18401 
    oprot.writeFieldStop()
18402 
    oprot.writeStructEnd()
18403 
 
18404 
  def validate(self):
18405 
    return
18406 
 
18407 
 
18408 
  def __repr__(self):
18409 
    L = ['%s=%r' % (key, value)
18410 
      for key, value in self.__dict__.iteritems()]
18411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18412 
 
18413 
  def __eq__(self, other):
18414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18415 
 
18416 
  def __ne__(self, other):
18417 
    return not (self == other)
18418 
 
4285 rajveer 18419 
class acceptOrdersForItemId_args:
18420 
  """
18421 
  Attributes:
18422 
   - itemId
18423 
   - inventory
18424 
  """
18425 
 
18426 
  thrift_spec = (
18427 
    None, # 0
18428 
    (1, TType.I64, 'itemId', None, None, ), # 1
18429 
    (2, TType.I64, 'inventory', None, None, ), # 2
18430 
  )
18431 
 
18432 
  def __init__(self, itemId=None, inventory=None,):
18433 
    self.itemId = itemId
18434 
    self.inventory = inventory
18435 
 
18436 
  def read(self, iprot):
18437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18439 
      return
18440 
    iprot.readStructBegin()
18441 
    while True:
18442 
      (fname, ftype, fid) = iprot.readFieldBegin()
18443 
      if ftype == TType.STOP:
18444 
        break
18445 
      if fid == 1:
18446 
        if ftype == TType.I64:
18447 
          self.itemId = iprot.readI64();
18448 
        else:
18449 
          iprot.skip(ftype)
18450 
      elif fid == 2:
18451 
        if ftype == TType.I64:
18452 
          self.inventory = iprot.readI64();
18453 
        else:
18454 
          iprot.skip(ftype)
18455 
      else:
18456 
        iprot.skip(ftype)
18457 
      iprot.readFieldEnd()
18458 
    iprot.readStructEnd()
18459 
 
18460 
  def write(self, oprot):
18461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18463 
      return
18464 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
18465 
    if self.itemId is not None:
18466 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18467 
      oprot.writeI64(self.itemId)
18468 
      oprot.writeFieldEnd()
18469 
    if self.inventory is not None:
18470 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
18471 
      oprot.writeI64(self.inventory)
18472 
      oprot.writeFieldEnd()
18473 
    oprot.writeFieldStop()
18474 
    oprot.writeStructEnd()
18475 
 
18476 
  def validate(self):
18477 
    return
18478 
 
18479 
 
18480 
  def __repr__(self):
18481 
    L = ['%s=%r' % (key, value)
18482 
      for key, value in self.__dict__.iteritems()]
18483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18484 
 
18485 
  def __eq__(self, other):
18486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18487 
 
18488 
  def __ne__(self, other):
18489 
    return not (self == other)
18490 
 
18491 
class acceptOrdersForItemId_result:
18492 
  """
18493 
  Attributes:
18494 
   - success
18495 
   - ex
18496 
  """
18497 
 
18498 
  thrift_spec = (
18499 
    (0, TType.BOOL, 'success', None, None, ), # 0
18500 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18501 
  )
18502 
 
18503 
  def __init__(self, success=None, ex=None,):
18504 
    self.success = success
18505 
    self.ex = ex
18506 
 
18507 
  def read(self, iprot):
18508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18510 
      return
18511 
    iprot.readStructBegin()
18512 
    while True:
18513 
      (fname, ftype, fid) = iprot.readFieldBegin()
18514 
      if ftype == TType.STOP:
18515 
        break
18516 
      if fid == 0:
18517 
        if ftype == TType.BOOL:
18518 
          self.success = iprot.readBool();
18519 
        else:
18520 
          iprot.skip(ftype)
18521 
      elif fid == 1:
18522 
        if ftype == TType.STRUCT:
18523 
          self.ex = TransactionServiceException()
18524 
          self.ex.read(iprot)
18525 
        else:
18526 
          iprot.skip(ftype)
18527 
      else:
18528 
        iprot.skip(ftype)
18529 
      iprot.readFieldEnd()
18530 
    iprot.readStructEnd()
18531 
 
18532 
  def write(self, oprot):
18533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18535 
      return
18536 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
18537 
    if self.success is not None:
18538 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18539 
      oprot.writeBool(self.success)
18540 
      oprot.writeFieldEnd()
18541 
    if self.ex is not None:
18542 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18543 
      self.ex.write(oprot)
18544 
      oprot.writeFieldEnd()
18545 
    oprot.writeFieldStop()
18546 
    oprot.writeStructEnd()
18547 
 
18548 
  def validate(self):
18549 
    return
18550 
 
18551 
 
18552 
  def __repr__(self):
18553 
    L = ['%s=%r' % (key, value)
18554 
      for key, value in self.__dict__.iteritems()]
18555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18556 
 
18557 
  def __eq__(self, other):
18558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18559 
 
18560 
  def __ne__(self, other):
18561 
    return not (self == other)
4303 rajveer 18562 
 
18563 
class markOrdersAsPORaised_args:
18564 
  """
18565 
  Attributes:
18566 
   - vendorId
18567 
   - itemId
18568 
   - quantity
18569 
   - estimate
4369 rajveer 18570 
   - isReminder
4303 rajveer 18571 
  """
18572 
 
18573 
  thrift_spec = (
18574 
    None, # 0
18575 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18576 
    (2, TType.I64, 'itemId', None, None, ), # 2
18577 
    (3, TType.I64, 'quantity', None, None, ), # 3
18578 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18579 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18580 
  )
18581 
 
4369 rajveer 18582 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18583 
    self.vendorId = vendorId
18584 
    self.itemId = itemId
18585 
    self.quantity = quantity
18586 
    self.estimate = estimate
4369 rajveer 18587 
    self.isReminder = isReminder
4303 rajveer 18588 
 
18589 
  def read(self, iprot):
18590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18592 
      return
18593 
    iprot.readStructBegin()
18594 
    while True:
18595 
      (fname, ftype, fid) = iprot.readFieldBegin()
18596 
      if ftype == TType.STOP:
18597 
        break
18598 
      if fid == 1:
18599 
        if ftype == TType.I64:
18600 
          self.vendorId = iprot.readI64();
18601 
        else:
18602 
          iprot.skip(ftype)
18603 
      elif fid == 2:
18604 
        if ftype == TType.I64:
18605 
          self.itemId = iprot.readI64();
18606 
        else:
18607 
          iprot.skip(ftype)
18608 
      elif fid == 3:
18609 
        if ftype == TType.I64:
18610 
          self.quantity = iprot.readI64();
18611 
        else:
18612 
          iprot.skip(ftype)
18613 
      elif fid == 4:
18614 
        if ftype == TType.I64:
18615 
          self.estimate = iprot.readI64();
18616 
        else:
18617 
          iprot.skip(ftype)
4369 rajveer 18618 
      elif fid == 5:
18619 
        if ftype == TType.BOOL:
18620 
          self.isReminder = iprot.readBool();
18621 
        else:
18622 
          iprot.skip(ftype)
4303 rajveer 18623 
      else:
18624 
        iprot.skip(ftype)
18625 
      iprot.readFieldEnd()
18626 
    iprot.readStructEnd()
18627 
 
18628 
  def write(self, oprot):
18629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18631 
      return
18632 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
18633 
    if self.vendorId is not None:
18634 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18635 
      oprot.writeI64(self.vendorId)
18636 
      oprot.writeFieldEnd()
18637 
    if self.itemId is not None:
18638 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18639 
      oprot.writeI64(self.itemId)
18640 
      oprot.writeFieldEnd()
18641 
    if self.quantity is not None:
18642 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18643 
      oprot.writeI64(self.quantity)
18644 
      oprot.writeFieldEnd()
18645 
    if self.estimate is not None:
18646 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18647 
      oprot.writeI64(self.estimate)
18648 
      oprot.writeFieldEnd()
4369 rajveer 18649 
    if self.isReminder is not None:
18650 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18651 
      oprot.writeBool(self.isReminder)
18652 
      oprot.writeFieldEnd()
4303 rajveer 18653 
    oprot.writeFieldStop()
18654 
    oprot.writeStructEnd()
18655 
 
18656 
  def validate(self):
18657 
    return
18658 
 
18659 
 
18660 
  def __repr__(self):
18661 
    L = ['%s=%r' % (key, value)
18662 
      for key, value in self.__dict__.iteritems()]
18663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18664 
 
18665 
  def __eq__(self, other):
18666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18667 
 
18668 
  def __ne__(self, other):
18669 
    return not (self == other)
18670 
 
18671 
class markOrdersAsPORaised_result:
18672 
  """
18673 
  Attributes:
18674 
   - ex
18675 
  """
18676 
 
18677 
  thrift_spec = (
18678 
    None, # 0
18679 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18680 
  )
18681 
 
18682 
  def __init__(self, ex=None,):
18683 
    self.ex = ex
18684 
 
18685 
  def read(self, iprot):
18686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18688 
      return
18689 
    iprot.readStructBegin()
18690 
    while True:
18691 
      (fname, ftype, fid) = iprot.readFieldBegin()
18692 
      if ftype == TType.STOP:
18693 
        break
18694 
      if fid == 1:
18695 
        if ftype == TType.STRUCT:
18696 
          self.ex = TransactionServiceException()
18697 
          self.ex.read(iprot)
18698 
        else:
18699 
          iprot.skip(ftype)
18700 
      else:
18701 
        iprot.skip(ftype)
18702 
      iprot.readFieldEnd()
18703 
    iprot.readStructEnd()
18704 
 
18705 
  def write(self, oprot):
18706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18708 
      return
18709 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
18710 
    if self.ex is not None:
18711 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18712 
      self.ex.write(oprot)
18713 
      oprot.writeFieldEnd()
18714 
    oprot.writeFieldStop()
18715 
    oprot.writeStructEnd()
18716 
 
18717 
  def validate(self):
18718 
    return
18719 
 
18720 
 
18721 
  def __repr__(self):
18722 
    L = ['%s=%r' % (key, value)
18723 
      for key, value in self.__dict__.iteritems()]
18724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18725 
 
18726 
  def __eq__(self, other):
18727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18728 
 
18729 
  def __ne__(self, other):
18730 
    return not (self == other)
18731 
 
18732 
class markOrdersAsReversalInitiated_args:
18733 
  """
18734 
  Attributes:
18735 
   - vendorId
18736 
   - itemId
18737 
   - quantity
18738 
   - estimate
4369 rajveer 18739 
   - isReminder
4303 rajveer 18740 
  """
18741 
 
18742 
  thrift_spec = (
18743 
    None, # 0
18744 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18745 
    (2, TType.I64, 'itemId', None, None, ), # 2
18746 
    (3, TType.I64, 'quantity', None, None, ), # 3
18747 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18748 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18749 
  )
18750 
 
4369 rajveer 18751 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18752 
    self.vendorId = vendorId
18753 
    self.itemId = itemId
18754 
    self.quantity = quantity
18755 
    self.estimate = estimate
4369 rajveer 18756 
    self.isReminder = isReminder
4303 rajveer 18757 
 
18758 
  def read(self, iprot):
18759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18761 
      return
18762 
    iprot.readStructBegin()
18763 
    while True:
18764 
      (fname, ftype, fid) = iprot.readFieldBegin()
18765 
      if ftype == TType.STOP:
18766 
        break
18767 
      if fid == 1:
18768 
        if ftype == TType.I64:
18769 
          self.vendorId = iprot.readI64();
18770 
        else:
18771 
          iprot.skip(ftype)
18772 
      elif fid == 2:
18773 
        if ftype == TType.I64:
18774 
          self.itemId = iprot.readI64();
18775 
        else:
18776 
          iprot.skip(ftype)
18777 
      elif fid == 3:
18778 
        if ftype == TType.I64:
18779 
          self.quantity = iprot.readI64();
18780 
        else:
18781 
          iprot.skip(ftype)
18782 
      elif fid == 4:
18783 
        if ftype == TType.I64:
18784 
          self.estimate = iprot.readI64();
18785 
        else:
18786 
          iprot.skip(ftype)
4369 rajveer 18787 
      elif fid == 5:
18788 
        if ftype == TType.BOOL:
18789 
          self.isReminder = iprot.readBool();
18790 
        else:
18791 
          iprot.skip(ftype)
4303 rajveer 18792 
      else:
18793 
        iprot.skip(ftype)
18794 
      iprot.readFieldEnd()
18795 
    iprot.readStructEnd()
18796 
 
18797 
  def write(self, oprot):
18798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18800 
      return
18801 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
18802 
    if self.vendorId is not None:
18803 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18804 
      oprot.writeI64(self.vendorId)
18805 
      oprot.writeFieldEnd()
18806 
    if self.itemId is not None:
18807 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18808 
      oprot.writeI64(self.itemId)
18809 
      oprot.writeFieldEnd()
18810 
    if self.quantity is not None:
18811 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18812 
      oprot.writeI64(self.quantity)
18813 
      oprot.writeFieldEnd()
18814 
    if self.estimate is not None:
18815 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18816 
      oprot.writeI64(self.estimate)
18817 
      oprot.writeFieldEnd()
4369 rajveer 18818 
    if self.isReminder is not None:
18819 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18820 
      oprot.writeBool(self.isReminder)
18821 
      oprot.writeFieldEnd()
4303 rajveer 18822 
    oprot.writeFieldStop()
18823 
    oprot.writeStructEnd()
18824 
 
18825 
  def validate(self):
18826 
    return
18827 
 
18828 
 
18829 
  def __repr__(self):
18830 
    L = ['%s=%r' % (key, value)
18831 
      for key, value in self.__dict__.iteritems()]
18832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18833 
 
18834 
  def __eq__(self, other):
18835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18836 
 
18837 
  def __ne__(self, other):
18838 
    return not (self == other)
18839 
 
18840 
class markOrdersAsReversalInitiated_result:
18841 
  """
18842 
  Attributes:
18843 
   - ex
18844 
  """
18845 
 
18846 
  thrift_spec = (
18847 
    None, # 0
18848 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18849 
  )
18850 
 
18851 
  def __init__(self, ex=None,):
18852 
    self.ex = ex
18853 
 
18854 
  def read(self, iprot):
18855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18857 
      return
18858 
    iprot.readStructBegin()
18859 
    while True:
18860 
      (fname, ftype, fid) = iprot.readFieldBegin()
18861 
      if ftype == TType.STOP:
18862 
        break
18863 
      if fid == 1:
18864 
        if ftype == TType.STRUCT:
18865 
          self.ex = TransactionServiceException()
18866 
          self.ex.read(iprot)
18867 
        else:
18868 
          iprot.skip(ftype)
18869 
      else:
18870 
        iprot.skip(ftype)
18871 
      iprot.readFieldEnd()
18872 
    iprot.readStructEnd()
18873 
 
18874 
  def write(self, oprot):
18875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18877 
      return
18878 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
18879 
    if self.ex is not None:
18880 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18881 
      self.ex.write(oprot)
18882 
      oprot.writeFieldEnd()
18883 
    oprot.writeFieldStop()
18884 
    oprot.writeStructEnd()
18885 
 
18886 
  def validate(self):
18887 
    return
18888 
 
18889 
 
18890 
  def __repr__(self):
18891 
    L = ['%s=%r' % (key, value)
18892 
      for key, value in self.__dict__.iteritems()]
18893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18894 
 
18895 
  def __eq__(self, other):
18896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18897 
 
18898 
  def __ne__(self, other):
18899 
    return not (self == other)
18900 
 
18901 
class markOrdersAsNotAvailabke_args:
18902 
  """
18903 
  Attributes:
18904 
   - vendorId
18905 
   - itemId
18906 
   - quantity
18907 
   - estimate
4369 rajveer 18908 
   - isReminder
4303 rajveer 18909 
  """
18910 
 
18911 
  thrift_spec = (
18912 
    None, # 0
18913 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18914 
    (2, TType.I64, 'itemId', None, None, ), # 2
18915 
    (3, TType.I64, 'quantity', None, None, ), # 3
18916 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18917 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18918 
  )
18919 
 
4369 rajveer 18920 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18921 
    self.vendorId = vendorId
18922 
    self.itemId = itemId
18923 
    self.quantity = quantity
18924 
    self.estimate = estimate
4369 rajveer 18925 
    self.isReminder = isReminder
4303 rajveer 18926 
 
18927 
  def read(self, iprot):
18928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18930 
      return
18931 
    iprot.readStructBegin()
18932 
    while True:
18933 
      (fname, ftype, fid) = iprot.readFieldBegin()
18934 
      if ftype == TType.STOP:
18935 
        break
18936 
      if fid == 1:
18937 
        if ftype == TType.I64:
18938 
          self.vendorId = iprot.readI64();
18939 
        else:
18940 
          iprot.skip(ftype)
18941 
      elif fid == 2:
18942 
        if ftype == TType.I64:
18943 
          self.itemId = iprot.readI64();
18944 
        else:
18945 
          iprot.skip(ftype)
18946 
      elif fid == 3:
18947 
        if ftype == TType.I64:
18948 
          self.quantity = iprot.readI64();
18949 
        else:
18950 
          iprot.skip(ftype)
18951 
      elif fid == 4:
18952 
        if ftype == TType.I64:
18953 
          self.estimate = iprot.readI64();
18954 
        else:
18955 
          iprot.skip(ftype)
4369 rajveer 18956 
      elif fid == 5:
18957 
        if ftype == TType.BOOL:
18958 
          self.isReminder = iprot.readBool();
18959 
        else:
18960 
          iprot.skip(ftype)
4303 rajveer 18961 
      else:
18962 
        iprot.skip(ftype)
18963 
      iprot.readFieldEnd()
18964 
    iprot.readStructEnd()
18965 
 
18966 
  def write(self, oprot):
18967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18969 
      return
18970 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
18971 
    if self.vendorId is not None:
18972 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18973 
      oprot.writeI64(self.vendorId)
18974 
      oprot.writeFieldEnd()
18975 
    if self.itemId is not None:
18976 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18977 
      oprot.writeI64(self.itemId)
18978 
      oprot.writeFieldEnd()
18979 
    if self.quantity is not None:
18980 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18981 
      oprot.writeI64(self.quantity)
18982 
      oprot.writeFieldEnd()
18983 
    if self.estimate is not None:
18984 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18985 
      oprot.writeI64(self.estimate)
18986 
      oprot.writeFieldEnd()
4369 rajveer 18987 
    if self.isReminder is not None:
18988 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18989 
      oprot.writeBool(self.isReminder)
18990 
      oprot.writeFieldEnd()
4303 rajveer 18991 
    oprot.writeFieldStop()
18992 
    oprot.writeStructEnd()
18993 
 
18994 
  def validate(self):
18995 
    return
18996 
 
18997 
 
18998 
  def __repr__(self):
18999 
    L = ['%s=%r' % (key, value)
19000 
      for key, value in self.__dict__.iteritems()]
19001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19002 
 
19003 
  def __eq__(self, other):
19004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19005 
 
19006 
  def __ne__(self, other):
19007 
    return not (self == other)
19008 
 
19009 
class markOrdersAsNotAvailabke_result:
19010 
  """
19011 
  Attributes:
19012 
   - ex
19013 
  """
19014 
 
19015 
  thrift_spec = (
19016 
    None, # 0
19017 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19018 
  )
19019 
 
19020 
  def __init__(self, ex=None,):
19021 
    self.ex = ex
19022 
 
19023 
  def read(self, iprot):
19024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19026 
      return
19027 
    iprot.readStructBegin()
19028 
    while True:
19029 
      (fname, ftype, fid) = iprot.readFieldBegin()
19030 
      if ftype == TType.STOP:
19031 
        break
19032 
      if fid == 1:
19033 
        if ftype == TType.STRUCT:
19034 
          self.ex = TransactionServiceException()
19035 
          self.ex.read(iprot)
19036 
        else:
19037 
          iprot.skip(ftype)
19038 
      else:
19039 
        iprot.skip(ftype)
19040 
      iprot.readFieldEnd()
19041 
    iprot.readStructEnd()
19042 
 
19043 
  def write(self, oprot):
19044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19046 
      return
19047 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
19048 
    if self.ex is not None:
19049 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19050 
      self.ex.write(oprot)
19051 
      oprot.writeFieldEnd()
19052 
    oprot.writeFieldStop()
19053 
    oprot.writeStructEnd()
19054 
 
19055 
  def validate(self):
19056 
    return
19057 
 
19058 
 
19059 
  def __repr__(self):
19060 
    L = ['%s=%r' % (key, value)
19061 
      for key, value in self.__dict__.iteritems()]
19062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19063 
 
19064 
  def __eq__(self, other):
19065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19066 
 
19067 
  def __ne__(self, other):
19068 
    return not (self == other)
4369 rajveer 19069 
 
19070 
class markOrdersAsTimeout_args:
19071 
  """
19072 
  Attributes:
19073 
   - vendorId
19074 
  """
19075 
 
19076 
  thrift_spec = (
19077 
    None, # 0
19078 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19079 
  )
19080 
 
19081 
  def __init__(self, vendorId=None,):
19082 
    self.vendorId = vendorId
19083 
 
19084 
  def read(self, iprot):
19085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19087 
      return
19088 
    iprot.readStructBegin()
19089 
    while True:
19090 
      (fname, ftype, fid) = iprot.readFieldBegin()
19091 
      if ftype == TType.STOP:
19092 
        break
19093 
      if fid == 1:
19094 
        if ftype == TType.I64:
19095 
          self.vendorId = iprot.readI64();
19096 
        else:
19097 
          iprot.skip(ftype)
19098 
      else:
19099 
        iprot.skip(ftype)
19100 
      iprot.readFieldEnd()
19101 
    iprot.readStructEnd()
19102 
 
19103 
  def write(self, oprot):
19104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19106 
      return
19107 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
19108 
    if self.vendorId is not None:
19109 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19110 
      oprot.writeI64(self.vendorId)
19111 
      oprot.writeFieldEnd()
19112 
    oprot.writeFieldStop()
19113 
    oprot.writeStructEnd()
19114 
 
19115 
  def validate(self):
19116 
    return
19117 
 
19118 
 
19119 
  def __repr__(self):
19120 
    L = ['%s=%r' % (key, value)
19121 
      for key, value in self.__dict__.iteritems()]
19122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19123 
 
19124 
  def __eq__(self, other):
19125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19126 
 
19127 
  def __ne__(self, other):
19128 
    return not (self == other)
19129 
 
19130 
class markOrdersAsTimeout_result:
19131 
  """
19132 
  Attributes:
19133 
   - success
19134 
   - ex
19135 
  """
19136 
 
19137 
  thrift_spec = (
19138 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
19139 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19140 
  )
19141 
 
19142 
  def __init__(self, success=None, ex=None,):
19143 
    self.success = success
19144 
    self.ex = ex
19145 
 
19146 
  def read(self, iprot):
19147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19149 
      return
19150 
    iprot.readStructBegin()
19151 
    while True:
19152 
      (fname, ftype, fid) = iprot.readFieldBegin()
19153 
      if ftype == TType.STOP:
19154 
        break
19155 
      if fid == 0:
19156 
        if ftype == TType.MAP:
19157 
          self.success = {}
5031 varun.gupt 19158 
          (_ktype410, _vtype411, _size409 ) = iprot.readMapBegin()
19159 
          for _i413 in xrange(_size409):
19160 
            _key414 = iprot.readI32();
19161 
            _val415 = TimeoutSummary()
19162 
            _val415.read(iprot)
19163 
            self.success[_key414] = _val415
4369 rajveer 19164 
          iprot.readMapEnd()
19165 
        else:
19166 
          iprot.skip(ftype)
19167 
      elif fid == 1:
19168 
        if ftype == TType.STRUCT:
19169 
          self.ex = TransactionServiceException()
19170 
          self.ex.read(iprot)
19171 
        else:
19172 
          iprot.skip(ftype)
19173 
      else:
19174 
        iprot.skip(ftype)
19175 
      iprot.readFieldEnd()
19176 
    iprot.readStructEnd()
19177 
 
19178 
  def write(self, oprot):
19179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19181 
      return
19182 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
19183 
    if self.success is not None:
19184 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19185 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
5031 varun.gupt 19186 
      for kiter416,viter417 in self.success.items():
19187 
        oprot.writeI32(kiter416)
19188 
        viter417.write(oprot)
4369 rajveer 19189 
      oprot.writeMapEnd()
19190 
      oprot.writeFieldEnd()
19191 
    if self.ex is not None:
19192 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19193 
      self.ex.write(oprot)
19194 
      oprot.writeFieldEnd()
19195 
    oprot.writeFieldStop()
19196 
    oprot.writeStructEnd()
19197 
 
19198 
  def validate(self):
19199 
    return
19200 
 
19201 
 
19202 
  def __repr__(self):
19203 
    L = ['%s=%r' % (key, value)
19204 
      for key, value in self.__dict__.iteritems()]
19205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19206 
 
19207 
  def __eq__(self, other):
19208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19209 
 
19210 
  def __ne__(self, other):
19211 
    return not (self == other)
4386 anupam.sin 19212 
 
4662 rajveer 19213 
class markOrderAsLostInTransit_args:
19214 
  """
19215 
  Attributes:
19216 
   - orderId
19217 
  """
19218 
 
19219 
  thrift_spec = (
19220 
    None, # 0
19221 
    (1, TType.I64, 'orderId', None, None, ), # 1
19222 
  )
19223 
 
19224 
  def __init__(self, orderId=None,):
19225 
    self.orderId = orderId
19226 
 
19227 
  def read(self, iprot):
19228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19230 
      return
19231 
    iprot.readStructBegin()
19232 
    while True:
19233 
      (fname, ftype, fid) = iprot.readFieldBegin()
19234 
      if ftype == TType.STOP:
19235 
        break
19236 
      if fid == 1:
19237 
        if ftype == TType.I64:
19238 
          self.orderId = iprot.readI64();
19239 
        else:
19240 
          iprot.skip(ftype)
19241 
      else:
19242 
        iprot.skip(ftype)
19243 
      iprot.readFieldEnd()
19244 
    iprot.readStructEnd()
19245 
 
19246 
  def write(self, oprot):
19247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19249 
      return
19250 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
19251 
    if self.orderId is not None:
19252 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19253 
      oprot.writeI64(self.orderId)
19254 
      oprot.writeFieldEnd()
19255 
    oprot.writeFieldStop()
19256 
    oprot.writeStructEnd()
19257 
 
19258 
  def validate(self):
19259 
    return
19260 
 
19261 
 
19262 
  def __repr__(self):
19263 
    L = ['%s=%r' % (key, value)
19264 
      for key, value in self.__dict__.iteritems()]
19265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19266 
 
19267 
  def __eq__(self, other):
19268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19269 
 
19270 
  def __ne__(self, other):
19271 
    return not (self == other)
19272 
 
19273 
class markOrderAsLostInTransit_result:
19274 
  """
19275 
  Attributes:
19276 
   - success
19277 
   - ex
19278 
  """
19279 
 
19280 
  thrift_spec = (
19281 
    (0, TType.BOOL, 'success', None, None, ), # 0
19282 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19283 
  )
19284 
 
19285 
  def __init__(self, success=None, ex=None,):
19286 
    self.success = success
19287 
    self.ex = ex
19288 
 
19289 
  def read(self, iprot):
19290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19292 
      return
19293 
    iprot.readStructBegin()
19294 
    while True:
19295 
      (fname, ftype, fid) = iprot.readFieldBegin()
19296 
      if ftype == TType.STOP:
19297 
        break
19298 
      if fid == 0:
19299 
        if ftype == TType.BOOL:
19300 
          self.success = iprot.readBool();
19301 
        else:
19302 
          iprot.skip(ftype)
19303 
      elif fid == 1:
19304 
        if ftype == TType.STRUCT:
19305 
          self.ex = TransactionServiceException()
19306 
          self.ex.read(iprot)
19307 
        else:
19308 
          iprot.skip(ftype)
19309 
      else:
19310 
        iprot.skip(ftype)
19311 
      iprot.readFieldEnd()
19312 
    iprot.readStructEnd()
19313 
 
19314 
  def write(self, oprot):
19315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19317 
      return
19318 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
19319 
    if self.success is not None:
19320 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19321 
      oprot.writeBool(self.success)
19322 
      oprot.writeFieldEnd()
19323 
    if self.ex is not None:
19324 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19325 
      self.ex.write(oprot)
19326 
      oprot.writeFieldEnd()
19327 
    oprot.writeFieldStop()
19328 
    oprot.writeStructEnd()
19329 
 
19330 
  def validate(self):
19331 
    return
19332 
 
19333 
 
19334 
  def __repr__(self):
19335 
    L = ['%s=%r' % (key, value)
19336 
      for key, value in self.__dict__.iteritems()]
19337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19338 
 
19339 
  def __eq__(self, other):
19340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19341 
 
19342 
  def __ne__(self, other):
19343 
    return not (self == other)
19344 
 
4386 anupam.sin 19345 
class getOrderForAwb_args:
19346 
  """
19347 
  Attributes:
19348 
   - awb
19349 
  """
19350 
 
19351 
  thrift_spec = (
19352 
    None, # 0
19353 
    (1, TType.STRING, 'awb', None, None, ), # 1
19354 
  )
19355 
 
19356 
  def __init__(self, awb=None,):
19357 
    self.awb = awb
19358 
 
19359 
  def read(self, iprot):
19360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19362 
      return
19363 
    iprot.readStructBegin()
19364 
    while True:
19365 
      (fname, ftype, fid) = iprot.readFieldBegin()
19366 
      if ftype == TType.STOP:
19367 
        break
19368 
      if fid == 1:
19369 
        if ftype == TType.STRING:
19370 
          self.awb = iprot.readString();
19371 
        else:
19372 
          iprot.skip(ftype)
19373 
      else:
19374 
        iprot.skip(ftype)
19375 
      iprot.readFieldEnd()
19376 
    iprot.readStructEnd()
19377 
 
19378 
  def write(self, oprot):
19379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19381 
      return
19382 
    oprot.writeStructBegin('getOrderForAwb_args')
19383 
    if self.awb is not None:
19384 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
19385 
      oprot.writeString(self.awb)
19386 
      oprot.writeFieldEnd()
19387 
    oprot.writeFieldStop()
19388 
    oprot.writeStructEnd()
19389 
 
19390 
  def validate(self):
19391 
    return
19392 
 
19393 
 
19394 
  def __repr__(self):
19395 
    L = ['%s=%r' % (key, value)
19396 
      for key, value in self.__dict__.iteritems()]
19397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19398 
 
19399 
  def __eq__(self, other):
19400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19401 
 
19402 
  def __ne__(self, other):
19403 
    return not (self == other)
19404 
 
19405 
class getOrderForAwb_result:
19406 
  """
19407 
  Attributes:
19408 
   - success
19409 
   - ex
19410 
  """
19411 
 
19412 
  thrift_spec = (
19413 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19414 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19415 
  )
19416 
 
19417 
  def __init__(self, success=None, ex=None,):
19418 
    self.success = success
19419 
    self.ex = ex
19420 
 
19421 
  def read(self, iprot):
19422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19424 
      return
19425 
    iprot.readStructBegin()
19426 
    while True:
19427 
      (fname, ftype, fid) = iprot.readFieldBegin()
19428 
      if ftype == TType.STOP:
19429 
        break
19430 
      if fid == 0:
19431 
        if ftype == TType.STRUCT:
19432 
          self.success = Order()
19433 
          self.success.read(iprot)
19434 
        else:
19435 
          iprot.skip(ftype)
19436 
      elif fid == 1:
19437 
        if ftype == TType.STRUCT:
19438 
          self.ex = TransactionServiceException()
19439 
          self.ex.read(iprot)
19440 
        else:
19441 
          iprot.skip(ftype)
19442 
      else:
19443 
        iprot.skip(ftype)
19444 
      iprot.readFieldEnd()
19445 
    iprot.readStructEnd()
19446 
 
19447 
  def write(self, oprot):
19448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19450 
      return
19451 
    oprot.writeStructBegin('getOrderForAwb_result')
19452 
    if self.success is not None:
19453 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19454 
      self.success.write(oprot)
19455 
      oprot.writeFieldEnd()
19456 
    if self.ex is not None:
19457 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19458 
      self.ex.write(oprot)
19459 
      oprot.writeFieldEnd()
19460 
    oprot.writeFieldStop()
19461 
    oprot.writeStructEnd()
19462 
 
19463 
  def validate(self):
19464 
    return
19465 
 
19466 
 
19467 
  def __repr__(self):
19468 
    L = ['%s=%r' % (key, value)
19469 
      for key, value in self.__dict__.iteritems()]
19470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19471 
 
19472 
  def __eq__(self, other):
19473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19474 
 
19475 
  def __ne__(self, other):
19476 
    return not (self == other)
4506 phani.kuma 19477 
 
19478 
class getOrdersForProviderForStatus_args:
19479 
  """
19480 
  Attributes:
19481 
   - logistics_provider_id
4910 phani.kuma 19482 
   - order_status_list
4506 phani.kuma 19483 
  """
19484 
 
19485 
  thrift_spec = (
19486 
    None, # 0
19487 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 19488 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 19489 
  )
19490 
 
4910 phani.kuma 19491 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 19492 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 19493 
    self.order_status_list = order_status_list
4506 phani.kuma 19494 
 
19495 
  def read(self, iprot):
19496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19498 
      return
19499 
    iprot.readStructBegin()
19500 
    while True:
19501 
      (fname, ftype, fid) = iprot.readFieldBegin()
19502 
      if ftype == TType.STOP:
19503 
        break
19504 
      if fid == 1:
19505 
        if ftype == TType.I64:
19506 
          self.logistics_provider_id = iprot.readI64();
19507 
        else:
19508 
          iprot.skip(ftype)
19509 
      elif fid == 2:
4910 phani.kuma 19510 
        if ftype == TType.LIST:
19511 
          self.order_status_list = []
5031 varun.gupt 19512 
          (_etype421, _size418) = iprot.readListBegin()
19513 
          for _i422 in xrange(_size418):
19514 
            _elem423 = iprot.readI32();
19515 
            self.order_status_list.append(_elem423)
4910 phani.kuma 19516 
          iprot.readListEnd()
4506 phani.kuma 19517 
        else:
19518 
          iprot.skip(ftype)
19519 
      else:
19520 
        iprot.skip(ftype)
19521 
      iprot.readFieldEnd()
19522 
    iprot.readStructEnd()
19523 
 
19524 
  def write(self, oprot):
19525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19527 
      return
19528 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
19529 
    if self.logistics_provider_id is not None:
19530 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
19531 
      oprot.writeI64(self.logistics_provider_id)
19532 
      oprot.writeFieldEnd()
4910 phani.kuma 19533 
    if self.order_status_list is not None:
19534 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
19535 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
5031 varun.gupt 19536 
      for iter424 in self.order_status_list:
19537 
        oprot.writeI32(iter424)
4910 phani.kuma 19538 
      oprot.writeListEnd()
4506 phani.kuma 19539 
      oprot.writeFieldEnd()
19540 
    oprot.writeFieldStop()
19541 
    oprot.writeStructEnd()
19542 
 
19543 
  def validate(self):
19544 
    return
19545 
 
19546 
 
19547 
  def __repr__(self):
19548 
    L = ['%s=%r' % (key, value)
19549 
      for key, value in self.__dict__.iteritems()]
19550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19551 
 
19552 
  def __eq__(self, other):
19553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19554 
 
19555 
  def __ne__(self, other):
19556 
    return not (self == other)
19557 
 
19558 
class getOrdersForProviderForStatus_result:
19559 
  """
19560 
  Attributes:
19561 
   - success
19562 
   - ex
19563 
  """
19564 
 
19565 
  thrift_spec = (
19566 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19567 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19568 
  )
19569 
 
19570 
  def __init__(self, success=None, ex=None,):
19571 
    self.success = success
19572 
    self.ex = ex
19573 
 
19574 
  def read(self, iprot):
19575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19577 
      return
19578 
    iprot.readStructBegin()
19579 
    while True:
19580 
      (fname, ftype, fid) = iprot.readFieldBegin()
19581 
      if ftype == TType.STOP:
19582 
        break
19583 
      if fid == 0:
19584 
        if ftype == TType.LIST:
19585 
          self.success = []
5031 varun.gupt 19586 
          (_etype428, _size425) = iprot.readListBegin()
19587 
          for _i429 in xrange(_size425):
19588 
            _elem430 = Order()
19589 
            _elem430.read(iprot)
19590 
            self.success.append(_elem430)
4506 phani.kuma 19591 
          iprot.readListEnd()
19592 
        else:
19593 
          iprot.skip(ftype)
19594 
      elif fid == 1:
19595 
        if ftype == TType.STRUCT:
19596 
          self.ex = TransactionServiceException()
19597 
          self.ex.read(iprot)
19598 
        else:
19599 
          iprot.skip(ftype)
19600 
      else:
19601 
        iprot.skip(ftype)
19602 
      iprot.readFieldEnd()
19603 
    iprot.readStructEnd()
19604 
 
19605 
  def write(self, oprot):
19606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19608 
      return
19609 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
19610 
    if self.success is not None:
19611 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19612 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19613 
      for iter431 in self.success:
19614 
        iter431.write(oprot)
4506 phani.kuma 19615 
      oprot.writeListEnd()
19616 
      oprot.writeFieldEnd()
19617 
    if self.ex is not None:
19618 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19619 
      self.ex.write(oprot)
19620 
      oprot.writeFieldEnd()
19621 
    oprot.writeFieldStop()
19622 
    oprot.writeStructEnd()
19623 
 
19624 
  def validate(self):
19625 
    return
19626 
 
19627 
 
19628 
  def __repr__(self):
19629 
    L = ['%s=%r' % (key, value)
19630 
      for key, value in self.__dict__.iteritems()]
19631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19632 
 
19633 
  def __eq__(self, other):
19634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19635 
 
19636 
  def __ne__(self, other):
19637 
    return not (self == other)
4600 varun.gupt 19638 
 
19639 
class getBilledOrdersForVendor_args:
19640 
  """
19641 
  Attributes:
19642 
   - vendorId
19643 
   - billingDateFrom
19644 
   - billingDateTo
19645 
  """
19646 
 
19647 
  thrift_spec = (
19648 
    None, # 0
19649 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19650 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
19651 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
19652 
  )
19653 
 
19654 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
19655 
    self.vendorId = vendorId
19656 
    self.billingDateFrom = billingDateFrom
19657 
    self.billingDateTo = billingDateTo
19658 
 
19659 
  def read(self, iprot):
19660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19662 
      return
19663 
    iprot.readStructBegin()
19664 
    while True:
19665 
      (fname, ftype, fid) = iprot.readFieldBegin()
19666 
      if ftype == TType.STOP:
19667 
        break
19668 
      if fid == 1:
19669 
        if ftype == TType.I64:
19670 
          self.vendorId = iprot.readI64();
19671 
        else:
19672 
          iprot.skip(ftype)
19673 
      elif fid == 2:
19674 
        if ftype == TType.I64:
19675 
          self.billingDateFrom = iprot.readI64();
19676 
        else:
19677 
          iprot.skip(ftype)
19678 
      elif fid == 3:
19679 
        if ftype == TType.I64:
19680 
          self.billingDateTo = iprot.readI64();
19681 
        else:
19682 
          iprot.skip(ftype)
19683 
      else:
19684 
        iprot.skip(ftype)
19685 
      iprot.readFieldEnd()
19686 
    iprot.readStructEnd()
19687 
 
19688 
  def write(self, oprot):
19689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19691 
      return
19692 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
19693 
    if self.vendorId is not None:
19694 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19695 
      oprot.writeI64(self.vendorId)
19696 
      oprot.writeFieldEnd()
19697 
    if self.billingDateFrom is not None:
19698 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
19699 
      oprot.writeI64(self.billingDateFrom)
19700 
      oprot.writeFieldEnd()
19701 
    if self.billingDateTo is not None:
19702 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
19703 
      oprot.writeI64(self.billingDateTo)
19704 
      oprot.writeFieldEnd()
19705 
    oprot.writeFieldStop()
19706 
    oprot.writeStructEnd()
19707 
 
19708 
  def validate(self):
19709 
    return
19710 
 
19711 
 
19712 
  def __repr__(self):
19713 
    L = ['%s=%r' % (key, value)
19714 
      for key, value in self.__dict__.iteritems()]
19715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19716 
 
19717 
  def __eq__(self, other):
19718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19719 
 
19720 
  def __ne__(self, other):
19721 
    return not (self == other)
19722 
 
19723 
class getBilledOrdersForVendor_result:
19724 
  """
19725 
  Attributes:
19726 
   - success
19727 
   - ex
19728 
  """
19729 
 
19730 
  thrift_spec = (
19731 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19732 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19733 
  )
19734 
 
19735 
  def __init__(self, success=None, ex=None,):
19736 
    self.success = success
19737 
    self.ex = ex
19738 
 
19739 
  def read(self, iprot):
19740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19742 
      return
19743 
    iprot.readStructBegin()
19744 
    while True:
19745 
      (fname, ftype, fid) = iprot.readFieldBegin()
19746 
      if ftype == TType.STOP:
19747 
        break
19748 
      if fid == 0:
19749 
        if ftype == TType.LIST:
19750 
          self.success = []
5031 varun.gupt 19751 
          (_etype435, _size432) = iprot.readListBegin()
19752 
          for _i436 in xrange(_size432):
19753 
            _elem437 = Order()
19754 
            _elem437.read(iprot)
19755 
            self.success.append(_elem437)
4600 varun.gupt 19756 
          iprot.readListEnd()
19757 
        else:
19758 
          iprot.skip(ftype)
19759 
      elif fid == 1:
19760 
        if ftype == TType.STRUCT:
19761 
          self.ex = TransactionServiceException()
19762 
          self.ex.read(iprot)
19763 
        else:
19764 
          iprot.skip(ftype)
19765 
      else:
19766 
        iprot.skip(ftype)
19767 
      iprot.readFieldEnd()
19768 
    iprot.readStructEnd()
19769 
 
19770 
  def write(self, oprot):
19771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19773 
      return
19774 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
19775 
    if self.success is not None:
19776 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19777 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19778 
      for iter438 in self.success:
19779 
        iter438.write(oprot)
4600 varun.gupt 19780 
      oprot.writeListEnd()
19781 
      oprot.writeFieldEnd()
19782 
    if self.ex is not None:
19783 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19784 
      self.ex.write(oprot)
19785 
      oprot.writeFieldEnd()
19786 
    oprot.writeFieldStop()
19787 
    oprot.writeStructEnd()
19788 
 
19789 
  def validate(self):
19790 
    return
19791 
 
19792 
 
19793 
  def __repr__(self):
19794 
    L = ['%s=%r' % (key, value)
19795 
      for key, value in self.__dict__.iteritems()]
19796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19797 
 
19798 
  def __eq__(self, other):
19799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19800 
 
19801 
  def __ne__(self, other):
19802 
    return not (self == other)
19803 
 
4607 rajveer 19804 
class getSlippedSippingDateOrders_args:
19805 
 
19806 
  thrift_spec = (
19807 
  )
19808 
 
19809 
  def read(self, iprot):
19810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19812 
      return
19813 
    iprot.readStructBegin()
19814 
    while True:
19815 
      (fname, ftype, fid) = iprot.readFieldBegin()
19816 
      if ftype == TType.STOP:
19817 
        break
19818 
      else:
19819 
        iprot.skip(ftype)
19820 
      iprot.readFieldEnd()
19821 
    iprot.readStructEnd()
19822 
 
19823 
  def write(self, oprot):
19824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19826 
      return
19827 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
19828 
    oprot.writeFieldStop()
19829 
    oprot.writeStructEnd()
19830 
 
19831 
  def validate(self):
19832 
    return
19833 
 
19834 
 
19835 
  def __repr__(self):
19836 
    L = ['%s=%r' % (key, value)
19837 
      for key, value in self.__dict__.iteritems()]
19838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19839 
 
19840 
  def __eq__(self, other):
19841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19842 
 
19843 
  def __ne__(self, other):
19844 
    return not (self == other)
19845 
 
19846 
class getSlippedSippingDateOrders_result:
19847 
  """
19848 
  Attributes:
19849 
   - success
19850 
   - ex
19851 
  """
19852 
 
19853 
  thrift_spec = (
19854 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19855 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19856 
  )
19857 
 
19858 
  def __init__(self, success=None, ex=None,):
19859 
    self.success = success
19860 
    self.ex = ex
19861 
 
19862 
  def read(self, iprot):
19863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19865 
      return
19866 
    iprot.readStructBegin()
19867 
    while True:
19868 
      (fname, ftype, fid) = iprot.readFieldBegin()
19869 
      if ftype == TType.STOP:
19870 
        break
19871 
      if fid == 0:
19872 
        if ftype == TType.LIST:
19873 
          self.success = []
5031 varun.gupt 19874 
          (_etype442, _size439) = iprot.readListBegin()
19875 
          for _i443 in xrange(_size439):
19876 
            _elem444 = Order()
19877 
            _elem444.read(iprot)
19878 
            self.success.append(_elem444)
4607 rajveer 19879 
          iprot.readListEnd()
19880 
        else:
19881 
          iprot.skip(ftype)
19882 
      elif fid == 1:
19883 
        if ftype == TType.STRUCT:
19884 
          self.ex = TransactionServiceException()
19885 
          self.ex.read(iprot)
19886 
        else:
19887 
          iprot.skip(ftype)
19888 
      else:
19889 
        iprot.skip(ftype)
19890 
      iprot.readFieldEnd()
19891 
    iprot.readStructEnd()
19892 
 
19893 
  def write(self, oprot):
19894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19896 
      return
19897 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
19898 
    if self.success is not None:
19899 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19900 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19901 
      for iter445 in self.success:
19902 
        iter445.write(oprot)
4607 rajveer 19903 
      oprot.writeListEnd()
19904 
      oprot.writeFieldEnd()
19905 
    if self.ex is not None:
19906 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19907 
      self.ex.write(oprot)
19908 
      oprot.writeFieldEnd()
19909 
    oprot.writeFieldStop()
19910 
    oprot.writeStructEnd()
19911 
 
19912 
  def validate(self):
19913 
    return
19914 
 
19915 
 
19916 
  def __repr__(self):
19917 
    L = ['%s=%r' % (key, value)
19918 
      for key, value in self.__dict__.iteritems()]
19919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19920 
 
19921 
  def __eq__(self, other):
19922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19923 
 
19924 
  def __ne__(self, other):
19925 
    return not (self == other)
19926 
 
4709 rajveer 19927 
class getCancelledOrders_args:
19928 
  """
19929 
  Attributes:
19930 
   - cancelDateFrom
19931 
   - cancelDateTo
19932 
  """
19933 
 
19934 
  thrift_spec = (
19935 
    None, # 0
19936 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
19937 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
19938 
  )
19939 
 
19940 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
19941 
    self.cancelDateFrom = cancelDateFrom
19942 
    self.cancelDateTo = cancelDateTo
19943 
 
19944 
  def read(self, iprot):
19945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19947 
      return
19948 
    iprot.readStructBegin()
19949 
    while True:
19950 
      (fname, ftype, fid) = iprot.readFieldBegin()
19951 
      if ftype == TType.STOP:
19952 
        break
19953 
      if fid == 1:
19954 
        if ftype == TType.I64:
19955 
          self.cancelDateFrom = iprot.readI64();
19956 
        else:
19957 
          iprot.skip(ftype)
19958 
      elif fid == 2:
19959 
        if ftype == TType.I64:
19960 
          self.cancelDateTo = iprot.readI64();
19961 
        else:
19962 
          iprot.skip(ftype)
19963 
      else:
19964 
        iprot.skip(ftype)
19965 
      iprot.readFieldEnd()
19966 
    iprot.readStructEnd()
19967 
 
19968 
  def write(self, oprot):
19969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19971 
      return
19972 
    oprot.writeStructBegin('getCancelledOrders_args')
19973 
    if self.cancelDateFrom is not None:
19974 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
19975 
      oprot.writeI64(self.cancelDateFrom)
19976 
      oprot.writeFieldEnd()
19977 
    if self.cancelDateTo is not None:
19978 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
19979 
      oprot.writeI64(self.cancelDateTo)
19980 
      oprot.writeFieldEnd()
19981 
    oprot.writeFieldStop()
19982 
    oprot.writeStructEnd()
19983 
 
19984 
  def validate(self):
19985 
    return
19986 
 
19987 
 
19988 
  def __repr__(self):
19989 
    L = ['%s=%r' % (key, value)
19990 
      for key, value in self.__dict__.iteritems()]
19991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19992 
 
19993 
  def __eq__(self, other):
19994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19995 
 
19996 
  def __ne__(self, other):
19997 
    return not (self == other)
19998 
 
19999 
class getCancelledOrders_result:
20000 
  """
20001 
  Attributes:
20002 
   - success
20003 
   - ex
20004 
  """
20005 
 
20006 
  thrift_spec = (
20007 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20008 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20009 
  )
20010 
 
20011 
  def __init__(self, success=None, ex=None,):
20012 
    self.success = success
20013 
    self.ex = ex
20014 
 
20015 
  def read(self, iprot):
20016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20018 
      return
20019 
    iprot.readStructBegin()
20020 
    while True:
20021 
      (fname, ftype, fid) = iprot.readFieldBegin()
20022 
      if ftype == TType.STOP:
20023 
        break
20024 
      if fid == 0:
20025 
        if ftype == TType.LIST:
20026 
          self.success = []
5031 varun.gupt 20027 
          (_etype449, _size446) = iprot.readListBegin()
20028 
          for _i450 in xrange(_size446):
20029 
            _elem451 = Order()
20030 
            _elem451.read(iprot)
20031 
            self.success.append(_elem451)
4709 rajveer 20032 
          iprot.readListEnd()
20033 
        else:
20034 
          iprot.skip(ftype)
20035 
      elif fid == 1:
20036 
        if ftype == TType.STRUCT:
20037 
          self.ex = TransactionServiceException()
20038 
          self.ex.read(iprot)
20039 
        else:
20040 
          iprot.skip(ftype)
20041 
      else:
20042 
        iprot.skip(ftype)
20043 
      iprot.readFieldEnd()
20044 
    iprot.readStructEnd()
20045 
 
20046 
  def write(self, oprot):
20047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20049 
      return
20050 
    oprot.writeStructBegin('getCancelledOrders_result')
20051 
    if self.success is not None:
20052 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20053 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 20054 
      for iter452 in self.success:
20055 
        iter452.write(oprot)
4709 rajveer 20056 
      oprot.writeListEnd()
20057 
      oprot.writeFieldEnd()
20058 
    if self.ex is not None:
20059 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20060 
      self.ex.write(oprot)
20061 
      oprot.writeFieldEnd()
20062 
    oprot.writeFieldStop()
20063 
    oprot.writeStructEnd()
20064 
 
20065 
  def validate(self):
20066 
    return
20067 
 
20068 
 
20069 
  def __repr__(self):
20070 
    L = ['%s=%r' % (key, value)
20071 
      for key, value in self.__dict__.iteritems()]
20072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20073 
 
20074 
  def __eq__(self, other):
20075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20076 
 
20077 
  def __ne__(self, other):
20078 
    return not (self == other)
20079 
 
4600 varun.gupt 20080 
class saveBluedartSettlements_args:
20081 
  """
20082 
  Attributes:
20083 
   - mapAWBAndAmount
20084 
  """
20085 
 
20086 
  thrift_spec = (
20087 
    None, # 0
20088 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
20089 
  )
20090 
 
20091 
  def __init__(self, mapAWBAndAmount=None,):
20092 
    self.mapAWBAndAmount = mapAWBAndAmount
20093 
 
20094 
  def read(self, iprot):
20095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20097 
      return
20098 
    iprot.readStructBegin()
20099 
    while True:
20100 
      (fname, ftype, fid) = iprot.readFieldBegin()
20101 
      if ftype == TType.STOP:
20102 
        break
20103 
      if fid == 1:
20104 
        if ftype == TType.MAP:
20105 
          self.mapAWBAndAmount = {}
5031 varun.gupt 20106 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
20107 
          for _i457 in xrange(_size453):
20108 
            _key458 = iprot.readI64();
20109 
            _val459 = iprot.readDouble();
20110 
            self.mapAWBAndAmount[_key458] = _val459
4600 varun.gupt 20111 
          iprot.readMapEnd()
20112 
        else:
20113 
          iprot.skip(ftype)
20114 
      else:
20115 
        iprot.skip(ftype)
20116 
      iprot.readFieldEnd()
20117 
    iprot.readStructEnd()
20118 
 
20119 
  def write(self, oprot):
20120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20122 
      return
20123 
    oprot.writeStructBegin('saveBluedartSettlements_args')
20124 
    if self.mapAWBAndAmount is not None:
20125 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
20126 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
5031 varun.gupt 20127 
      for kiter460,viter461 in self.mapAWBAndAmount.items():
20128 
        oprot.writeI64(kiter460)
20129 
        oprot.writeDouble(viter461)
4600 varun.gupt 20130 
      oprot.writeMapEnd()
20131 
      oprot.writeFieldEnd()
20132 
    oprot.writeFieldStop()
20133 
    oprot.writeStructEnd()
20134 
 
20135 
  def validate(self):
20136 
    return
20137 
 
20138 
 
20139 
  def __repr__(self):
20140 
    L = ['%s=%r' % (key, value)
20141 
      for key, value in self.__dict__.iteritems()]
20142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20143 
 
20144 
  def __eq__(self, other):
20145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20146 
 
20147 
  def __ne__(self, other):
20148 
    return not (self == other)
20149 
 
20150 
class saveBluedartSettlements_result:
20151 
  """
20152 
  Attributes:
20153 
   - ex
20154 
  """
20155 
 
20156 
  thrift_spec = (
20157 
    None, # 0
20158 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20159 
  )
20160 
 
20161 
  def __init__(self, ex=None,):
20162 
    self.ex = ex
20163 
 
20164 
  def read(self, iprot):
20165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20167 
      return
20168 
    iprot.readStructBegin()
20169 
    while True:
20170 
      (fname, ftype, fid) = iprot.readFieldBegin()
20171 
      if ftype == TType.STOP:
20172 
        break
20173 
      if fid == 1:
20174 
        if ftype == TType.STRUCT:
20175 
          self.ex = TransactionServiceException()
20176 
          self.ex.read(iprot)
20177 
        else:
20178 
          iprot.skip(ftype)
20179 
      else:
20180 
        iprot.skip(ftype)
20181 
      iprot.readFieldEnd()
20182 
    iprot.readStructEnd()
20183 
 
20184 
  def write(self, oprot):
20185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20187 
      return
20188 
    oprot.writeStructBegin('saveBluedartSettlements_result')
20189 
    if self.ex is not None:
20190 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20191 
      self.ex.write(oprot)
20192 
      oprot.writeFieldEnd()
20193 
    oprot.writeFieldStop()
20194 
    oprot.writeStructEnd()
20195 
 
20196 
  def validate(self):
20197 
    return
20198 
 
20199 
 
20200 
  def __repr__(self):
20201 
    L = ['%s=%r' % (key, value)
20202 
      for key, value in self.__dict__.iteritems()]
20203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20204 
 
20205 
  def __eq__(self, other):
20206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20207 
 
20208 
  def __ne__(self, other):
20209 
    return not (self == other)
20210 
 
20211 
class savePaymentSettlements_args:
20212 
  """
20213 
  Attributes:
20214 
   - settlementDate
20215 
   - paymentGatewayId
4905 varun.gupt 20216 
   - referenceId
4600 varun.gupt 20217 
   - serviceTax
20218 
   - otherCharges
20219 
   - netCollection
20220 
  """
20221 
 
20222 
  thrift_spec = (
20223 
    None, # 0
20224 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
20225 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 20226 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 20227 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
20228 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
20229 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
20230 
  )
20231 
 
4905 varun.gupt 20232 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 20233 
    self.settlementDate = settlementDate
20234 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 20235 
    self.referenceId = referenceId
4600 varun.gupt 20236 
    self.serviceTax = serviceTax
20237 
    self.otherCharges = otherCharges
20238 
    self.netCollection = netCollection
20239 
 
20240 
  def read(self, iprot):
20241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20243 
      return
20244 
    iprot.readStructBegin()
20245 
    while True:
20246 
      (fname, ftype, fid) = iprot.readFieldBegin()
20247 
      if ftype == TType.STOP:
20248 
        break
20249 
      if fid == 1:
20250 
        if ftype == TType.I64:
20251 
          self.settlementDate = iprot.readI64();
20252 
        else:
20253 
          iprot.skip(ftype)
20254 
      elif fid == 2:
20255 
        if ftype == TType.I64:
20256 
          self.paymentGatewayId = iprot.readI64();
20257 
        else:
20258 
          iprot.skip(ftype)
20259 
      elif fid == 3:
20260 
        if ftype == TType.I64:
4905 varun.gupt 20261 
          self.referenceId = iprot.readI64();
4600 varun.gupt 20262 
        else:
20263 
          iprot.skip(ftype)
20264 
      elif fid == 4:
20265 
        if ftype == TType.DOUBLE:
20266 
          self.serviceTax = iprot.readDouble();
20267 
        else:
20268 
          iprot.skip(ftype)
20269 
      elif fid == 5:
20270 
        if ftype == TType.DOUBLE:
20271 
          self.otherCharges = iprot.readDouble();
20272 
        else:
20273 
          iprot.skip(ftype)
20274 
      elif fid == 6:
20275 
        if ftype == TType.DOUBLE:
20276 
          self.netCollection = iprot.readDouble();
20277 
        else:
20278 
          iprot.skip(ftype)
20279 
      else:
20280 
        iprot.skip(ftype)
20281 
      iprot.readFieldEnd()
20282 
    iprot.readStructEnd()
20283 
 
20284 
  def write(self, oprot):
20285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20287 
      return
20288 
    oprot.writeStructBegin('savePaymentSettlements_args')
20289 
    if self.settlementDate is not None:
20290 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
20291 
      oprot.writeI64(self.settlementDate)
20292 
      oprot.writeFieldEnd()
20293 
    if self.paymentGatewayId is not None:
20294 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
20295 
      oprot.writeI64(self.paymentGatewayId)
20296 
      oprot.writeFieldEnd()
4905 varun.gupt 20297 
    if self.referenceId is not None:
20298 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
20299 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 20300 
      oprot.writeFieldEnd()
20301 
    if self.serviceTax is not None:
20302 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
20303 
      oprot.writeDouble(self.serviceTax)
20304 
      oprot.writeFieldEnd()
20305 
    if self.otherCharges is not None:
20306 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
20307 
      oprot.writeDouble(self.otherCharges)
20308 
      oprot.writeFieldEnd()
20309 
    if self.netCollection is not None:
20310 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
20311 
      oprot.writeDouble(self.netCollection)
20312 
      oprot.writeFieldEnd()
20313 
    oprot.writeFieldStop()
20314 
    oprot.writeStructEnd()
20315 
 
20316 
  def validate(self):
20317 
    return
20318 
 
20319 
 
20320 
  def __repr__(self):
20321 
    L = ['%s=%r' % (key, value)
20322 
      for key, value in self.__dict__.iteritems()]
20323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20324 
 
20325 
  def __eq__(self, other):
20326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20327 
 
20328 
  def __ne__(self, other):
20329 
    return not (self == other)
20330 
 
20331 
class savePaymentSettlements_result:
20332 
  """
20333 
  Attributes:
20334 
   - ex
20335 
  """
20336 
 
20337 
  thrift_spec = (
20338 
    None, # 0
20339 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20340 
  )
20341 
 
20342 
  def __init__(self, ex=None,):
20343 
    self.ex = ex
20344 
 
20345 
  def read(self, iprot):
20346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20348 
      return
20349 
    iprot.readStructBegin()
20350 
    while True:
20351 
      (fname, ftype, fid) = iprot.readFieldBegin()
20352 
      if ftype == TType.STOP:
20353 
        break
20354 
      if fid == 1:
20355 
        if ftype == TType.STRUCT:
20356 
          self.ex = TransactionServiceException()
20357 
          self.ex.read(iprot)
20358 
        else:
20359 
          iprot.skip(ftype)
20360 
      else:
20361 
        iprot.skip(ftype)
20362 
      iprot.readFieldEnd()
20363 
    iprot.readStructEnd()
20364 
 
20365 
  def write(self, oprot):
20366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20368 
      return
20369 
    oprot.writeStructBegin('savePaymentSettlements_result')
20370 
    if self.ex is not None:
20371 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20372 
      self.ex.write(oprot)
20373 
      oprot.writeFieldEnd()
20374 
    oprot.writeFieldStop()
20375 
    oprot.writeStructEnd()
20376 
 
20377 
  def validate(self):
20378 
    return
20379 
 
20380 
 
20381 
  def __repr__(self):
20382 
    L = ['%s=%r' % (key, value)
20383 
      for key, value in self.__dict__.iteritems()]
20384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20385 
 
20386 
  def __eq__(self, other):
20387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20388 
 
20389 
  def __ne__(self, other):
20390 
    return not (self == other)
20391 
 
20392 
class saveEBSSettlementSummary_args:
20393 
  """
20394 
  Attributes:
20395 
   - settlementId
20396 
   - settlementDate
20397 
   - transactionDateFrom
20398 
   - transactionDateTo
20399 
   - amount
20400 
  """
20401 
 
20402 
  thrift_spec = (
20403 
    None, # 0
20404 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20405 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
20406 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
20407 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
20408 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
20409 
  )
20410 
 
20411 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
20412 
    self.settlementId = settlementId
20413 
    self.settlementDate = settlementDate
20414 
    self.transactionDateFrom = transactionDateFrom
20415 
    self.transactionDateTo = transactionDateTo
20416 
    self.amount = amount
20417 
 
20418 
  def read(self, iprot):
20419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20421 
      return
20422 
    iprot.readStructBegin()
20423 
    while True:
20424 
      (fname, ftype, fid) = iprot.readFieldBegin()
20425 
      if ftype == TType.STOP:
20426 
        break
20427 
      if fid == 1:
20428 
        if ftype == TType.I64:
20429 
          self.settlementId = iprot.readI64();
20430 
        else:
20431 
          iprot.skip(ftype)
20432 
      elif fid == 2:
20433 
        if ftype == TType.I64:
20434 
          self.settlementDate = iprot.readI64();
20435 
        else:
20436 
          iprot.skip(ftype)
20437 
      elif fid == 3:
20438 
        if ftype == TType.I64:
20439 
          self.transactionDateFrom = iprot.readI64();
20440 
        else:
20441 
          iprot.skip(ftype)
20442 
      elif fid == 4:
20443 
        if ftype == TType.I64:
20444 
          self.transactionDateTo = iprot.readI64();
20445 
        else:
20446 
          iprot.skip(ftype)
20447 
      elif fid == 5:
20448 
        if ftype == TType.DOUBLE:
20449 
          self.amount = iprot.readDouble();
20450 
        else:
20451 
          iprot.skip(ftype)
20452 
      else:
20453 
        iprot.skip(ftype)
20454 
      iprot.readFieldEnd()
20455 
    iprot.readStructEnd()
20456 
 
20457 
  def write(self, oprot):
20458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20460 
      return
20461 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
20462 
    if self.settlementId is not None:
20463 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20464 
      oprot.writeI64(self.settlementId)
20465 
      oprot.writeFieldEnd()
20466 
    if self.settlementDate is not None:
20467 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
20468 
      oprot.writeI64(self.settlementDate)
20469 
      oprot.writeFieldEnd()
20470 
    if self.transactionDateFrom is not None:
20471 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
20472 
      oprot.writeI64(self.transactionDateFrom)
20473 
      oprot.writeFieldEnd()
20474 
    if self.transactionDateTo is not None:
20475 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
20476 
      oprot.writeI64(self.transactionDateTo)
20477 
      oprot.writeFieldEnd()
20478 
    if self.amount is not None:
20479 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
20480 
      oprot.writeDouble(self.amount)
20481 
      oprot.writeFieldEnd()
20482 
    oprot.writeFieldStop()
20483 
    oprot.writeStructEnd()
20484 
 
20485 
  def validate(self):
20486 
    return
20487 
 
20488 
 
20489 
  def __repr__(self):
20490 
    L = ['%s=%r' % (key, value)
20491 
      for key, value in self.__dict__.iteritems()]
20492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20493 
 
20494 
  def __eq__(self, other):
20495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20496 
 
20497 
  def __ne__(self, other):
20498 
    return not (self == other)
20499 
 
20500 
class saveEBSSettlementSummary_result:
20501 
  """
20502 
  Attributes:
20503 
   - ex
20504 
  """
20505 
 
20506 
  thrift_spec = (
20507 
    None, # 0
20508 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20509 
  )
20510 
 
20511 
  def __init__(self, ex=None,):
20512 
    self.ex = ex
20513 
 
20514 
  def read(self, iprot):
20515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20517 
      return
20518 
    iprot.readStructBegin()
20519 
    while True:
20520 
      (fname, ftype, fid) = iprot.readFieldBegin()
20521 
      if ftype == TType.STOP:
20522 
        break
20523 
      if fid == 1:
20524 
        if ftype == TType.STRUCT:
20525 
          self.ex = TransactionServiceException()
20526 
          self.ex.read(iprot)
20527 
        else:
20528 
          iprot.skip(ftype)
20529 
      else:
20530 
        iprot.skip(ftype)
20531 
      iprot.readFieldEnd()
20532 
    iprot.readStructEnd()
20533 
 
20534 
  def write(self, oprot):
20535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20537 
      return
20538 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
20539 
    if self.ex is not None:
20540 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20541 
      self.ex.write(oprot)
20542 
      oprot.writeFieldEnd()
20543 
    oprot.writeFieldStop()
20544 
    oprot.writeStructEnd()
20545 
 
20546 
  def validate(self):
20547 
    return
20548 
 
20549 
 
20550 
  def __repr__(self):
20551 
    L = ['%s=%r' % (key, value)
20552 
      for key, value in self.__dict__.iteritems()]
20553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20554 
 
20555 
  def __eq__(self, other):
20556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20557 
 
20558 
  def __ne__(self, other):
20559 
    return not (self == other)
20560 
 
5189 varun.gupt 20561 
class getSettlementForReferenceId_args:
4600 varun.gupt 20562 
  """
20563 
  Attributes:
5189 varun.gupt 20564 
   - referenceId
20565 
   - isRefund
4600 varun.gupt 20566 
  """
20567 
 
20568 
  thrift_spec = (
20569 
    None, # 0
5189 varun.gupt 20570 
    (1, TType.I64, 'referenceId', None, None, ), # 1
20571 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 20572 
  )
20573 
 
5189 varun.gupt 20574 
  def __init__(self, referenceId=None, isRefund=None,):
20575 
    self.referenceId = referenceId
20576 
    self.isRefund = isRefund
4600 varun.gupt 20577 
 
20578 
  def read(self, iprot):
20579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20581 
      return
20582 
    iprot.readStructBegin()
20583 
    while True:
20584 
      (fname, ftype, fid) = iprot.readFieldBegin()
20585 
      if ftype == TType.STOP:
20586 
        break
20587 
      if fid == 1:
20588 
        if ftype == TType.I64:
5189 varun.gupt 20589 
          self.referenceId = iprot.readI64();
4600 varun.gupt 20590 
        else:
20591 
          iprot.skip(ftype)
5189 varun.gupt 20592 
      elif fid == 2:
20593 
        if ftype == TType.BOOL:
20594 
          self.isRefund = iprot.readBool();
20595 
        else:
20596 
          iprot.skip(ftype)
4600 varun.gupt 20597 
      else:
20598 
        iprot.skip(ftype)
20599 
      iprot.readFieldEnd()
20600 
    iprot.readStructEnd()
20601 
 
20602 
  def write(self, oprot):
20603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20605 
      return
5189 varun.gupt 20606 
    oprot.writeStructBegin('getSettlementForReferenceId_args')
20607 
    if self.referenceId is not None:
20608 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
20609 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 20610 
      oprot.writeFieldEnd()
5189 varun.gupt 20611 
    if self.isRefund is not None:
20612 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
20613 
      oprot.writeBool(self.isRefund)
20614 
      oprot.writeFieldEnd()
4600 varun.gupt 20615 
    oprot.writeFieldStop()
20616 
    oprot.writeStructEnd()
20617 
 
20618 
  def validate(self):
20619 
    return
20620 
 
20621 
 
20622 
  def __repr__(self):
20623 
    L = ['%s=%r' % (key, value)
20624 
      for key, value in self.__dict__.iteritems()]
20625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20626 
 
20627 
  def __eq__(self, other):
20628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20629 
 
20630 
  def __ne__(self, other):
20631 
    return not (self == other)
20632 
 
5189 varun.gupt 20633 
class getSettlementForReferenceId_result:
4600 varun.gupt 20634 
  """
20635 
  Attributes:
20636 
   - success
20637 
   - ex
20638 
  """
20639 
 
20640 
  thrift_spec = (
20641 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
20642 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20643 
  )
20644 
 
20645 
  def __init__(self, success=None, ex=None,):
20646 
    self.success = success
20647 
    self.ex = ex
20648 
 
20649 
  def read(self, iprot):
20650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20652 
      return
20653 
    iprot.readStructBegin()
20654 
    while True:
20655 
      (fname, ftype, fid) = iprot.readFieldBegin()
20656 
      if ftype == TType.STOP:
20657 
        break
20658 
      if fid == 0:
20659 
        if ftype == TType.STRUCT:
20660 
          self.success = PaymentSettlement()
20661 
          self.success.read(iprot)
20662 
        else:
20663 
          iprot.skip(ftype)
20664 
      elif fid == 1:
20665 
        if ftype == TType.STRUCT:
20666 
          self.ex = TransactionServiceException()
20667 
          self.ex.read(iprot)
20668 
        else:
20669 
          iprot.skip(ftype)
20670 
      else:
20671 
        iprot.skip(ftype)
20672 
      iprot.readFieldEnd()
20673 
    iprot.readStructEnd()
20674 
 
20675 
  def write(self, oprot):
20676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20678 
      return
5189 varun.gupt 20679 
    oprot.writeStructBegin('getSettlementForReferenceId_result')
4600 varun.gupt 20680 
    if self.success is not None:
20681 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20682 
      self.success.write(oprot)
20683 
      oprot.writeFieldEnd()
20684 
    if self.ex is not None:
20685 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20686 
      self.ex.write(oprot)
20687 
      oprot.writeFieldEnd()
20688 
    oprot.writeFieldStop()
20689 
    oprot.writeStructEnd()
20690 
 
20691 
  def validate(self):
20692 
    return
20693 
 
20694 
 
20695 
  def __repr__(self):
20696 
    L = ['%s=%r' % (key, value)
20697 
      for key, value in self.__dict__.iteritems()]
20698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20699 
 
20700 
  def __eq__(self, other):
20701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20702 
 
20703 
  def __ne__(self, other):
20704 
    return not (self == other)
20705 
 
20706 
class getEBSSettlementSummaries_args:
20707 
 
20708 
  thrift_spec = (
20709 
  )
20710 
 
20711 
  def read(self, iprot):
20712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20714 
      return
20715 
    iprot.readStructBegin()
20716 
    while True:
20717 
      (fname, ftype, fid) = iprot.readFieldBegin()
20718 
      if ftype == TType.STOP:
20719 
        break
20720 
      else:
20721 
        iprot.skip(ftype)
20722 
      iprot.readFieldEnd()
20723 
    iprot.readStructEnd()
20724 
 
20725 
  def write(self, oprot):
20726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20728 
      return
20729 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
20730 
    oprot.writeFieldStop()
20731 
    oprot.writeStructEnd()
20732 
 
20733 
  def validate(self):
20734 
    return
20735 
 
20736 
 
20737 
  def __repr__(self):
20738 
    L = ['%s=%r' % (key, value)
20739 
      for key, value in self.__dict__.iteritems()]
20740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20741 
 
20742 
  def __eq__(self, other):
20743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20744 
 
20745 
  def __ne__(self, other):
20746 
    return not (self == other)
20747 
 
20748 
class getEBSSettlementSummaries_result:
20749 
  """
20750 
  Attributes:
20751 
   - success
20752 
   - ex
20753 
  """
20754 
 
20755 
  thrift_spec = (
20756 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
20757 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20758 
  )
20759 
 
20760 
  def __init__(self, success=None, ex=None,):
20761 
    self.success = success
20762 
    self.ex = ex
20763 
 
20764 
  def read(self, iprot):
20765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20767 
      return
20768 
    iprot.readStructBegin()
20769 
    while True:
20770 
      (fname, ftype, fid) = iprot.readFieldBegin()
20771 
      if ftype == TType.STOP:
20772 
        break
20773 
      if fid == 0:
20774 
        if ftype == TType.MAP:
20775 
          self.success = {}
5031 varun.gupt 20776 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20777 
          for _i466 in xrange(_size462):
20778 
            _key467 = iprot.readI64();
20779 
            _val468 = iprot.readString();
20780 
            self.success[_key467] = _val468
4600 varun.gupt 20781 
          iprot.readMapEnd()
20782 
        else:
20783 
          iprot.skip(ftype)
20784 
      elif fid == 1:
20785 
        if ftype == TType.STRUCT:
20786 
          self.ex = TransactionServiceException()
20787 
          self.ex.read(iprot)
20788 
        else:
20789 
          iprot.skip(ftype)
20790 
      else:
20791 
        iprot.skip(ftype)
20792 
      iprot.readFieldEnd()
20793 
    iprot.readStructEnd()
20794 
 
20795 
  def write(self, oprot):
20796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20798 
      return
20799 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
20800 
    if self.success is not None:
20801 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20802 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
5031 varun.gupt 20803 
      for kiter469,viter470 in self.success.items():
20804 
        oprot.writeI64(kiter469)
20805 
        oprot.writeString(viter470)
4600 varun.gupt 20806 
      oprot.writeMapEnd()
20807 
      oprot.writeFieldEnd()
20808 
    if self.ex is not None:
20809 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20810 
      self.ex.write(oprot)
20811 
      oprot.writeFieldEnd()
20812 
    oprot.writeFieldStop()
20813 
    oprot.writeStructEnd()
20814 
 
20815 
  def validate(self):
20816 
    return
20817 
 
20818 
 
20819 
  def __repr__(self):
20820 
    L = ['%s=%r' % (key, value)
20821 
      for key, value in self.__dict__.iteritems()]
20822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20823 
 
20824 
  def __eq__(self, other):
20825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20826 
 
20827 
  def __ne__(self, other):
20828 
    return not (self == other)
20829 
 
20830 
class markEBSSettlementUploaded_args:
20831 
  """
20832 
  Attributes:
20833 
   - settlementId
20834 
  """
20835 
 
20836 
  thrift_spec = (
20837 
    None, # 0
20838 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20839 
  )
20840 
 
20841 
  def __init__(self, settlementId=None,):
20842 
    self.settlementId = settlementId
20843 
 
20844 
  def read(self, iprot):
20845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20847 
      return
20848 
    iprot.readStructBegin()
20849 
    while True:
20850 
      (fname, ftype, fid) = iprot.readFieldBegin()
20851 
      if ftype == TType.STOP:
20852 
        break
20853 
      if fid == 1:
20854 
        if ftype == TType.I64:
20855 
          self.settlementId = iprot.readI64();
20856 
        else:
20857 
          iprot.skip(ftype)
20858 
      else:
20859 
        iprot.skip(ftype)
20860 
      iprot.readFieldEnd()
20861 
    iprot.readStructEnd()
20862 
 
20863 
  def write(self, oprot):
20864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20866 
      return
20867 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
20868 
    if self.settlementId is not None:
20869 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20870 
      oprot.writeI64(self.settlementId)
20871 
      oprot.writeFieldEnd()
20872 
    oprot.writeFieldStop()
20873 
    oprot.writeStructEnd()
20874 
 
20875 
  def validate(self):
20876 
    return
20877 
 
20878 
 
20879 
  def __repr__(self):
20880 
    L = ['%s=%r' % (key, value)
20881 
      for key, value in self.__dict__.iteritems()]
20882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20883 
 
20884 
  def __eq__(self, other):
20885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20886 
 
20887 
  def __ne__(self, other):
20888 
    return not (self == other)
20889 
 
20890 
class markEBSSettlementUploaded_result:
20891 
  """
20892 
  Attributes:
20893 
   - ex
20894 
  """
20895 
 
20896 
  thrift_spec = (
20897 
    None, # 0
20898 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20899 
  )
20900 
 
20901 
  def __init__(self, ex=None,):
20902 
    self.ex = ex
20903 
 
20904 
  def read(self, iprot):
20905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20907 
      return
20908 
    iprot.readStructBegin()
20909 
    while True:
20910 
      (fname, ftype, fid) = iprot.readFieldBegin()
20911 
      if ftype == TType.STOP:
20912 
        break
20913 
      if fid == 1:
20914 
        if ftype == TType.STRUCT:
20915 
          self.ex = TransactionServiceException()
20916 
          self.ex.read(iprot)
20917 
        else:
20918 
          iprot.skip(ftype)
20919 
      else:
20920 
        iprot.skip(ftype)
20921 
      iprot.readFieldEnd()
20922 
    iprot.readStructEnd()
20923 
 
20924 
  def write(self, oprot):
20925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20927 
      return
20928 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
20929 
    if self.ex is not None:
20930 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20931 
      self.ex.write(oprot)
20932 
      oprot.writeFieldEnd()
20933 
    oprot.writeFieldStop()
20934 
    oprot.writeStructEnd()
20935 
 
20936 
  def validate(self):
20937 
    return
20938 
 
20939 
 
20940 
  def __repr__(self):
20941 
    L = ['%s=%r' % (key, value)
20942 
      for key, value in self.__dict__.iteritems()]
20943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20944 
 
20945 
  def __eq__(self, other):
20946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20947 
 
20948 
  def __ne__(self, other):
20949 
    return not (self == other)
20950 
 
20951 
class getEBSSettlementDate_args:
20952 
  """
20953 
  Attributes:
20954 
   - settlementId
20955 
  """
20956 
 
20957 
  thrift_spec = (
20958 
    None, # 0
20959 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20960 
  )
20961 
 
20962 
  def __init__(self, settlementId=None,):
20963 
    self.settlementId = settlementId
20964 
 
20965 
  def read(self, iprot):
20966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20968 
      return
20969 
    iprot.readStructBegin()
20970 
    while True:
20971 
      (fname, ftype, fid) = iprot.readFieldBegin()
20972 
      if ftype == TType.STOP:
20973 
        break
20974 
      if fid == 1:
20975 
        if ftype == TType.I64:
20976 
          self.settlementId = iprot.readI64();
20977 
        else:
20978 
          iprot.skip(ftype)
20979 
      else:
20980 
        iprot.skip(ftype)
20981 
      iprot.readFieldEnd()
20982 
    iprot.readStructEnd()
20983 
 
20984 
  def write(self, oprot):
20985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20987 
      return
20988 
    oprot.writeStructBegin('getEBSSettlementDate_args')
20989 
    if self.settlementId is not None:
20990 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20991 
      oprot.writeI64(self.settlementId)
20992 
      oprot.writeFieldEnd()
20993 
    oprot.writeFieldStop()
20994 
    oprot.writeStructEnd()
20995 
 
20996 
  def validate(self):
20997 
    return
20998 
 
20999 
 
21000 
  def __repr__(self):
21001 
    L = ['%s=%r' % (key, value)
21002 
      for key, value in self.__dict__.iteritems()]
21003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21004 
 
21005 
  def __eq__(self, other):
21006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21007 
 
21008 
  def __ne__(self, other):
21009 
    return not (self == other)
21010 
 
21011 
class getEBSSettlementDate_result:
21012 
  """
21013 
  Attributes:
21014 
   - success
21015 
   - ex
21016 
  """
21017 
 
21018 
  thrift_spec = (
21019 
    (0, TType.I64, 'success', None, None, ), # 0
21020 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21021 
  )
21022 
 
21023 
  def __init__(self, success=None, ex=None,):
21024 
    self.success = success
21025 
    self.ex = ex
21026 
 
21027 
  def read(self, iprot):
21028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21030 
      return
21031 
    iprot.readStructBegin()
21032 
    while True:
21033 
      (fname, ftype, fid) = iprot.readFieldBegin()
21034 
      if ftype == TType.STOP:
21035 
        break
21036 
      if fid == 0:
21037 
        if ftype == TType.I64:
21038 
          self.success = iprot.readI64();
21039 
        else:
21040 
          iprot.skip(ftype)
21041 
      elif fid == 1:
21042 
        if ftype == TType.STRUCT:
21043 
          self.ex = TransactionServiceException()
21044 
          self.ex.read(iprot)
21045 
        else:
21046 
          iprot.skip(ftype)
21047 
      else:
21048 
        iprot.skip(ftype)
21049 
      iprot.readFieldEnd()
21050 
    iprot.readStructEnd()
21051 
 
21052 
  def write(self, oprot):
21053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21055 
      return
21056 
    oprot.writeStructBegin('getEBSSettlementDate_result')
21057 
    if self.success is not None:
21058 
      oprot.writeFieldBegin('success', TType.I64, 0)
21059 
      oprot.writeI64(self.success)
21060 
      oprot.writeFieldEnd()
21061 
    if self.ex is not None:
21062 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21063 
      self.ex.write(oprot)
21064 
      oprot.writeFieldEnd()
21065 
    oprot.writeFieldStop()
21066 
    oprot.writeStructEnd()
21067 
 
21068 
  def validate(self):
21069 
    return
21070 
 
21071 
 
21072 
  def __repr__(self):
21073 
    L = ['%s=%r' % (key, value)
21074 
      for key, value in self.__dict__.iteritems()]
21075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21076 
 
21077 
  def __eq__(self, other):
21078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21079 
 
21080 
  def __ne__(self, other):
21081 
    return not (self == other)
4715 varun.gupt 21082 
 
21083 
class getSettlementsByDate_args:
21084 
  """
21085 
  Attributes:
21086 
   - settlementDateFrom
21087 
   - settlementDateTo
21088 
   - isRefund
21089 
  """
21090 
 
21091 
  thrift_spec = (
21092 
    None, # 0
21093 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
21094 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
21095 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
21096 
  )
21097 
 
21098 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
21099 
    self.settlementDateFrom = settlementDateFrom
21100 
    self.settlementDateTo = settlementDateTo
21101 
    self.isRefund = isRefund
21102 
 
21103 
  def read(self, iprot):
21104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21106 
      return
21107 
    iprot.readStructBegin()
21108 
    while True:
21109 
      (fname, ftype, fid) = iprot.readFieldBegin()
21110 
      if ftype == TType.STOP:
21111 
        break
21112 
      if fid == 1:
21113 
        if ftype == TType.I64:
21114 
          self.settlementDateFrom = iprot.readI64();
21115 
        else:
21116 
          iprot.skip(ftype)
21117 
      elif fid == 2:
21118 
        if ftype == TType.I64:
21119 
          self.settlementDateTo = iprot.readI64();
21120 
        else:
21121 
          iprot.skip(ftype)
21122 
      elif fid == 3:
21123 
        if ftype == TType.BOOL:
21124 
          self.isRefund = iprot.readBool();
21125 
        else:
21126 
          iprot.skip(ftype)
21127 
      else:
21128 
        iprot.skip(ftype)
21129 
      iprot.readFieldEnd()
21130 
    iprot.readStructEnd()
21131 
 
21132 
  def write(self, oprot):
21133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21135 
      return
21136 
    oprot.writeStructBegin('getSettlementsByDate_args')
21137 
    if self.settlementDateFrom is not None:
21138 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
21139 
      oprot.writeI64(self.settlementDateFrom)
21140 
      oprot.writeFieldEnd()
21141 
    if self.settlementDateTo is not None:
21142 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
21143 
      oprot.writeI64(self.settlementDateTo)
21144 
      oprot.writeFieldEnd()
21145 
    if self.isRefund is not None:
21146 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
21147 
      oprot.writeBool(self.isRefund)
21148 
      oprot.writeFieldEnd()
21149 
    oprot.writeFieldStop()
21150 
    oprot.writeStructEnd()
21151 
 
21152 
  def validate(self):
21153 
    return
21154 
 
21155 
 
21156 
  def __repr__(self):
21157 
    L = ['%s=%r' % (key, value)
21158 
      for key, value in self.__dict__.iteritems()]
21159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21160 
 
21161 
  def __eq__(self, other):
21162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21163 
 
21164 
  def __ne__(self, other):
21165 
    return not (self == other)
21166 
 
21167 
class getSettlementsByDate_result:
21168 
  """
21169 
  Attributes:
21170 
   - success
21171 
   - ex
21172 
  """
21173 
 
21174 
  thrift_spec = (
21175 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
21176 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21177 
  )
21178 
 
21179 
  def __init__(self, success=None, ex=None,):
21180 
    self.success = success
21181 
    self.ex = ex
21182 
 
21183 
  def read(self, iprot):
21184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21186 
      return
21187 
    iprot.readStructBegin()
21188 
    while True:
21189 
      (fname, ftype, fid) = iprot.readFieldBegin()
21190 
      if ftype == TType.STOP:
21191 
        break
21192 
      if fid == 0:
21193 
        if ftype == TType.LIST:
21194 
          self.success = []
5031 varun.gupt 21195 
          (_etype474, _size471) = iprot.readListBegin()
21196 
          for _i475 in xrange(_size471):
21197 
            _elem476 = PaymentSettlement()
21198 
            _elem476.read(iprot)
21199 
            self.success.append(_elem476)
4715 varun.gupt 21200 
          iprot.readListEnd()
21201 
        else:
21202 
          iprot.skip(ftype)
21203 
      elif fid == 1:
21204 
        if ftype == TType.STRUCT:
21205 
          self.ex = TransactionServiceException()
21206 
          self.ex.read(iprot)
21207 
        else:
21208 
          iprot.skip(ftype)
21209 
      else:
21210 
        iprot.skip(ftype)
21211 
      iprot.readFieldEnd()
21212 
    iprot.readStructEnd()
21213 
 
21214 
  def write(self, oprot):
21215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21217 
      return
21218 
    oprot.writeStructBegin('getSettlementsByDate_result')
21219 
    if self.success is not None:
21220 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21221 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 21222 
      for iter477 in self.success:
21223 
        iter477.write(oprot)
4715 varun.gupt 21224 
      oprot.writeListEnd()
21225 
      oprot.writeFieldEnd()
21226 
    if self.ex is not None:
21227 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21228 
      self.ex.write(oprot)
21229 
      oprot.writeFieldEnd()
21230 
    oprot.writeFieldStop()
21231 
    oprot.writeStructEnd()
21232 
 
21233 
  def validate(self):
21234 
    return
21235 
 
21236 
 
21237 
  def __repr__(self):
21238 
    L = ['%s=%r' % (key, value)
21239 
      for key, value in self.__dict__.iteritems()]
21240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21241 
 
21242 
  def __eq__(self, other):
21243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21244 
 
21245 
  def __ne__(self, other):
21246 
    return not (self == other)
21247 
 
21248 
class getReshippedOrderIds_args:
21249 
  """
21250 
  Attributes:
21251 
   - orderIds
21252 
  """
21253 
 
21254 
  thrift_spec = (
21255 
    None, # 0
21256 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
21257 
  )
21258 
 
21259 
  def __init__(self, orderIds=None,):
21260 
    self.orderIds = orderIds
21261 
 
21262 
  def read(self, iprot):
21263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21265 
      return
21266 
    iprot.readStructBegin()
21267 
    while True:
21268 
      (fname, ftype, fid) = iprot.readFieldBegin()
21269 
      if ftype == TType.STOP:
21270 
        break
21271 
      if fid == 1:
21272 
        if ftype == TType.LIST:
21273 
          self.orderIds = []
5031 varun.gupt 21274 
          (_etype481, _size478) = iprot.readListBegin()
21275 
          for _i482 in xrange(_size478):
21276 
            _elem483 = iprot.readI64();
21277 
            self.orderIds.append(_elem483)
4715 varun.gupt 21278 
          iprot.readListEnd()
21279 
        else:
21280 
          iprot.skip(ftype)
21281 
      else:
21282 
        iprot.skip(ftype)
21283 
      iprot.readFieldEnd()
21284 
    iprot.readStructEnd()
21285 
 
21286 
  def write(self, oprot):
21287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21289 
      return
21290 
    oprot.writeStructBegin('getReshippedOrderIds_args')
21291 
    if self.orderIds is not None:
21292 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
21293 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5031 varun.gupt 21294 
      for iter484 in self.orderIds:
21295 
        oprot.writeI64(iter484)
4715 varun.gupt 21296 
      oprot.writeListEnd()
21297 
      oprot.writeFieldEnd()
21298 
    oprot.writeFieldStop()
21299 
    oprot.writeStructEnd()
21300 
 
21301 
  def validate(self):
21302 
    return
21303 
 
21304 
 
21305 
  def __repr__(self):
21306 
    L = ['%s=%r' % (key, value)
21307 
      for key, value in self.__dict__.iteritems()]
21308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21309 
 
21310 
  def __eq__(self, other):
21311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21312 
 
21313 
  def __ne__(self, other):
21314 
    return not (self == other)
21315 
 
21316 
class getReshippedOrderIds_result:
21317 
  """
21318 
  Attributes:
21319 
   - success
21320 
   - ex
21321 
  """
21322 
 
21323 
  thrift_spec = (
21324 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21325 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21326 
  )
21327 
 
21328 
  def __init__(self, success=None, ex=None,):
21329 
    self.success = success
21330 
    self.ex = ex
21331 
 
21332 
  def read(self, iprot):
21333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21335 
      return
21336 
    iprot.readStructBegin()
21337 
    while True:
21338 
      (fname, ftype, fid) = iprot.readFieldBegin()
21339 
      if ftype == TType.STOP:
21340 
        break
21341 
      if fid == 0:
21342 
        if ftype == TType.LIST:
21343 
          self.success = []
5031 varun.gupt 21344 
          (_etype488, _size485) = iprot.readListBegin()
21345 
          for _i489 in xrange(_size485):
21346 
            _elem490 = iprot.readI64();
21347 
            self.success.append(_elem490)
4715 varun.gupt 21348 
          iprot.readListEnd()
21349 
        else:
21350 
          iprot.skip(ftype)
21351 
      elif fid == 1:
21352 
        if ftype == TType.STRUCT:
21353 
          self.ex = TransactionServiceException()
21354 
          self.ex.read(iprot)
21355 
        else:
21356 
          iprot.skip(ftype)
21357 
      else:
21358 
        iprot.skip(ftype)
21359 
      iprot.readFieldEnd()
21360 
    iprot.readStructEnd()
21361 
 
21362 
  def write(self, oprot):
21363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21365 
      return
21366 
    oprot.writeStructBegin('getReshippedOrderIds_result')
21367 
    if self.success is not None:
21368 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21369 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 21370 
      for iter491 in self.success:
21371 
        oprot.writeI64(iter491)
4715 varun.gupt 21372 
      oprot.writeListEnd()
21373 
      oprot.writeFieldEnd()
21374 
    if self.ex is not None:
21375 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21376 
      self.ex.write(oprot)
21377 
      oprot.writeFieldEnd()
21378 
    oprot.writeFieldStop()
21379 
    oprot.writeStructEnd()
21380 
 
21381 
  def validate(self):
21382 
    return
21383 
 
21384 
 
21385 
  def __repr__(self):
21386 
    L = ['%s=%r' % (key, value)
21387 
      for key, value in self.__dict__.iteritems()]
21388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21389 
 
21390 
  def __eq__(self, other):
21391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21392 
 
21393 
  def __ne__(self, other):
21394 
    return not (self == other)
4757 mandeep.dh 21395 
 
21396 
class updateOrdersAsPORaised_args:
21397 
  """
21398 
  Attributes:
21399 
   - itemIdQuantityMap
21400 
   - purchaseOrderId
21401 
   - warehouseId
21402 
  """
21403 
 
21404 
  thrift_spec = (
21405 
    None, # 0
21406 
    (1, TType.MAP, 'itemIdQuantityMap', (TType.I64,None,TType.I64,None), None, ), # 1
21407 
    (2, TType.I64, 'purchaseOrderId', None, None, ), # 2
21408 
    (3, TType.I64, 'warehouseId', None, None, ), # 3
21409 
  )
21410 
 
21411 
  def __init__(self, itemIdQuantityMap=None, purchaseOrderId=None, warehouseId=None,):
21412 
    self.itemIdQuantityMap = itemIdQuantityMap
21413 
    self.purchaseOrderId = purchaseOrderId
21414 
    self.warehouseId = warehouseId
21415 
 
21416 
  def read(self, iprot):
21417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21419 
      return
21420 
    iprot.readStructBegin()
21421 
    while True:
21422 
      (fname, ftype, fid) = iprot.readFieldBegin()
21423 
      if ftype == TType.STOP:
21424 
        break
21425 
      if fid == 1:
21426 
        if ftype == TType.MAP:
21427 
          self.itemIdQuantityMap = {}
5031 varun.gupt 21428 
          (_ktype493, _vtype494, _size492 ) = iprot.readMapBegin()
21429 
          for _i496 in xrange(_size492):
21430 
            _key497 = iprot.readI64();
21431 
            _val498 = iprot.readI64();
21432 
            self.itemIdQuantityMap[_key497] = _val498
4757 mandeep.dh 21433 
          iprot.readMapEnd()
21434 
        else:
21435 
          iprot.skip(ftype)
21436 
      elif fid == 2:
21437 
        if ftype == TType.I64:
21438 
          self.purchaseOrderId = iprot.readI64();
21439 
        else:
21440 
          iprot.skip(ftype)
21441 
      elif fid == 3:
21442 
        if ftype == TType.I64:
21443 
          self.warehouseId = iprot.readI64();
21444 
        else:
21445 
          iprot.skip(ftype)
21446 
      else:
21447 
        iprot.skip(ftype)
21448 
      iprot.readFieldEnd()
21449 
    iprot.readStructEnd()
21450 
 
21451 
  def write(self, oprot):
21452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21454 
      return
21455 
    oprot.writeStructBegin('updateOrdersAsPORaised_args')
21456 
    if self.itemIdQuantityMap is not None:
21457 
      oprot.writeFieldBegin('itemIdQuantityMap', TType.MAP, 1)
21458 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemIdQuantityMap))
5031 varun.gupt 21459 
      for kiter499,viter500 in self.itemIdQuantityMap.items():
21460 
        oprot.writeI64(kiter499)
21461 
        oprot.writeI64(viter500)
4757 mandeep.dh 21462 
      oprot.writeMapEnd()
21463 
      oprot.writeFieldEnd()
21464 
    if self.purchaseOrderId is not None:
21465 
      oprot.writeFieldBegin('purchaseOrderId', TType.I64, 2)
21466 
      oprot.writeI64(self.purchaseOrderId)
21467 
      oprot.writeFieldEnd()
21468 
    if self.warehouseId is not None:
21469 
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
21470 
      oprot.writeI64(self.warehouseId)
21471 
      oprot.writeFieldEnd()
21472 
    oprot.writeFieldStop()
21473 
    oprot.writeStructEnd()
21474 
 
21475 
  def validate(self):
21476 
    return
21477 
 
21478 
 
21479 
  def __repr__(self):
21480 
    L = ['%s=%r' % (key, value)
21481 
      for key, value in self.__dict__.iteritems()]
21482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21483 
 
21484 
  def __eq__(self, other):
21485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21486 
 
21487 
  def __ne__(self, other):
21488 
    return not (self == other)
21489 
 
21490 
class updateOrdersAsPORaised_result:
21491 
  """
21492 
  Attributes:
21493 
   - ex
21494 
  """
21495 
 
21496 
  thrift_spec = (
21497 
    None, # 0
21498 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21499 
  )
21500 
 
21501 
  def __init__(self, ex=None,):
21502 
    self.ex = ex
21503 
 
21504 
  def read(self, iprot):
21505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21507 
      return
21508 
    iprot.readStructBegin()
21509 
    while True:
21510 
      (fname, ftype, fid) = iprot.readFieldBegin()
21511 
      if ftype == TType.STOP:
21512 
        break
21513 
      if fid == 1:
21514 
        if ftype == TType.STRUCT:
21515 
          self.ex = TransactionServiceException()
21516 
          self.ex.read(iprot)
21517 
        else:
21518 
          iprot.skip(ftype)
21519 
      else:
21520 
        iprot.skip(ftype)
21521 
      iprot.readFieldEnd()
21522 
    iprot.readStructEnd()
21523 
 
21524 
  def write(self, oprot):
21525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21527 
      return
21528 
    oprot.writeStructBegin('updateOrdersAsPORaised_result')
21529 
    if self.ex is not None:
21530 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21531 
      self.ex.write(oprot)
21532 
      oprot.writeFieldEnd()
21533 
    oprot.writeFieldStop()
21534 
    oprot.writeStructEnd()
21535 
 
21536 
  def validate(self):
21537 
    return
21538 
 
21539 
 
21540 
  def __repr__(self):
21541 
    L = ['%s=%r' % (key, value)
21542 
      for key, value in self.__dict__.iteritems()]
21543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21544 
 
21545 
  def __eq__(self, other):
21546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21547 
 
21548 
  def __ne__(self, other):
21549 
    return not (self == other)
4875 varun.gupt 21550 
 
21551 
class getOrdersWhereVendorNotPaid_args:
21552 
  """
21553 
  Attributes:
21554 
   - vendorId
21555 
  """
21556 
 
21557 
  thrift_spec = (
21558 
    None, # 0
21559 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21560 
  )
21561 
 
21562 
  def __init__(self, vendorId=None,):
21563 
    self.vendorId = vendorId
21564 
 
21565 
  def read(self, iprot):
21566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21568 
      return
21569 
    iprot.readStructBegin()
21570 
    while True:
21571 
      (fname, ftype, fid) = iprot.readFieldBegin()
21572 
      if ftype == TType.STOP:
21573 
        break
21574 
      if fid == 1:
21575 
        if ftype == TType.I64:
21576 
          self.vendorId = iprot.readI64();
21577 
        else:
21578 
          iprot.skip(ftype)
21579 
      else:
21580 
        iprot.skip(ftype)
21581 
      iprot.readFieldEnd()
21582 
    iprot.readStructEnd()
21583 
 
21584 
  def write(self, oprot):
21585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21587 
      return
21588 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_args')
21589 
    if self.vendorId is not None:
21590 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21591 
      oprot.writeI64(self.vendorId)
21592 
      oprot.writeFieldEnd()
21593 
    oprot.writeFieldStop()
21594 
    oprot.writeStructEnd()
21595 
 
21596 
  def validate(self):
21597 
    return
21598 
 
21599 
 
21600 
  def __repr__(self):
21601 
    L = ['%s=%r' % (key, value)
21602 
      for key, value in self.__dict__.iteritems()]
21603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21604 
 
21605 
  def __eq__(self, other):
21606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21607 
 
21608 
  def __ne__(self, other):
21609 
    return not (self == other)
21610 
 
21611 
class getOrdersWhereVendorNotPaid_result:
21612 
  """
21613 
  Attributes:
21614 
   - success
21615 
   - ex
21616 
  """
21617 
 
21618 
  thrift_spec = (
21619 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21620 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21621 
  )
21622 
 
21623 
  def __init__(self, success=None, ex=None,):
21624 
    self.success = success
21625 
    self.ex = ex
21626 
 
21627 
  def read(self, iprot):
21628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21630 
      return
21631 
    iprot.readStructBegin()
21632 
    while True:
21633 
      (fname, ftype, fid) = iprot.readFieldBegin()
21634 
      if ftype == TType.STOP:
21635 
        break
21636 
      if fid == 0:
21637 
        if ftype == TType.LIST:
21638 
          self.success = []
5031 varun.gupt 21639 
          (_etype504, _size501) = iprot.readListBegin()
21640 
          for _i505 in xrange(_size501):
21641 
            _elem506 = Order()
21642 
            _elem506.read(iprot)
21643 
            self.success.append(_elem506)
4875 varun.gupt 21644 
          iprot.readListEnd()
21645 
        else:
21646 
          iprot.skip(ftype)
21647 
      elif fid == 1:
21648 
        if ftype == TType.STRUCT:
21649 
          self.ex = TransactionServiceException()
21650 
          self.ex.read(iprot)
21651 
        else:
21652 
          iprot.skip(ftype)
21653 
      else:
21654 
        iprot.skip(ftype)
21655 
      iprot.readFieldEnd()
21656 
    iprot.readStructEnd()
21657 
 
21658 
  def write(self, oprot):
21659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21661 
      return
21662 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_result')
21663 
    if self.success is not None:
21664 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21665 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 21666 
      for iter507 in self.success:
21667 
        iter507.write(oprot)
4875 varun.gupt 21668 
      oprot.writeListEnd()
21669 
      oprot.writeFieldEnd()
21670 
    if self.ex is not None:
21671 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21672 
      self.ex.write(oprot)
21673 
      oprot.writeFieldEnd()
21674 
    oprot.writeFieldStop()
21675 
    oprot.writeStructEnd()
21676 
 
21677 
  def validate(self):
21678 
    return
21679 
 
21680 
 
21681 
  def __repr__(self):
21682 
    L = ['%s=%r' % (key, value)
21683 
      for key, value in self.__dict__.iteritems()]
21684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21685 
 
21686 
  def __eq__(self, other):
21687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21688 
 
21689 
  def __ne__(self, other):
21690 
    return not (self == other)
5031 varun.gupt 21691 
 
21692 
class getStatusDistributionOfOrders_args:
21693 
  """
21694 
  Attributes:
21695 
   - startDate
21696 
   - endDate
21697 
  """
21698 
 
21699 
  thrift_spec = (
21700 
    None, # 0
21701 
    (1, TType.I64, 'startDate', None, None, ), # 1
21702 
    (2, TType.I64, 'endDate', None, None, ), # 2
21703 
  )
21704 
 
21705 
  def __init__(self, startDate=None, endDate=None,):
21706 
    self.startDate = startDate
21707 
    self.endDate = endDate
21708 
 
21709 
  def read(self, iprot):
21710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21712 
      return
21713 
    iprot.readStructBegin()
21714 
    while True:
21715 
      (fname, ftype, fid) = iprot.readFieldBegin()
21716 
      if ftype == TType.STOP:
21717 
        break
21718 
      if fid == 1:
21719 
        if ftype == TType.I64:
21720 
          self.startDate = iprot.readI64();
21721 
        else:
21722 
          iprot.skip(ftype)
21723 
      elif fid == 2:
21724 
        if ftype == TType.I64:
21725 
          self.endDate = iprot.readI64();
21726 
        else:
21727 
          iprot.skip(ftype)
21728 
      else:
21729 
        iprot.skip(ftype)
21730 
      iprot.readFieldEnd()
21731 
    iprot.readStructEnd()
21732 
 
21733 
  def write(self, oprot):
21734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21736 
      return
21737 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
21738 
    if self.startDate is not None:
21739 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
21740 
      oprot.writeI64(self.startDate)
21741 
      oprot.writeFieldEnd()
21742 
    if self.endDate is not None:
21743 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
21744 
      oprot.writeI64(self.endDate)
21745 
      oprot.writeFieldEnd()
21746 
    oprot.writeFieldStop()
21747 
    oprot.writeStructEnd()
21748 
 
21749 
  def validate(self):
21750 
    return
21751 
 
21752 
 
21753 
  def __repr__(self):
21754 
    L = ['%s=%r' % (key, value)
21755 
      for key, value in self.__dict__.iteritems()]
21756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21757 
 
21758 
  def __eq__(self, other):
21759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21760 
 
21761 
  def __ne__(self, other):
21762 
    return not (self == other)
21763 
 
21764 
class getStatusDistributionOfOrders_result:
21765 
  """
21766 
  Attributes:
21767 
   - success
21768 
   - ex
21769 
  """
21770 
 
21771 
  thrift_spec = (
21772 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
21773 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21774 
  )
21775 
 
21776 
  def __init__(self, success=None, ex=None,):
21777 
    self.success = success
21778 
    self.ex = ex
21779 
 
21780 
  def read(self, iprot):
21781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21783 
      return
21784 
    iprot.readStructBegin()
21785 
    while True:
21786 
      (fname, ftype, fid) = iprot.readFieldBegin()
21787 
      if ftype == TType.STOP:
21788 
        break
21789 
      if fid == 0:
21790 
        if ftype == TType.MAP:
21791 
          self.success = {}
21792 
          (_ktype509, _vtype510, _size508 ) = iprot.readMapBegin()
21793 
          for _i512 in xrange(_size508):
21794 
            _key513 = iprot.readI64();
21795 
            _val514 = iprot.readI64();
21796 
            self.success[_key513] = _val514
21797 
          iprot.readMapEnd()
21798 
        else:
21799 
          iprot.skip(ftype)
21800 
      elif fid == 1:
21801 
        if ftype == TType.STRUCT:
21802 
          self.ex = TransactionServiceException()
21803 
          self.ex.read(iprot)
21804 
        else:
21805 
          iprot.skip(ftype)
21806 
      else:
21807 
        iprot.skip(ftype)
21808 
      iprot.readFieldEnd()
21809 
    iprot.readStructEnd()
21810 
 
21811 
  def write(self, oprot):
21812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21814 
      return
21815 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
21816 
    if self.success is not None:
21817 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21818 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
21819 
      for kiter515,viter516 in self.success.items():
21820 
        oprot.writeI64(kiter515)
21821 
        oprot.writeI64(viter516)
21822 
      oprot.writeMapEnd()
21823 
      oprot.writeFieldEnd()
21824 
    if self.ex is not None:
21825 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21826 
      self.ex.write(oprot)
21827 
      oprot.writeFieldEnd()
21828 
    oprot.writeFieldStop()
21829 
    oprot.writeStructEnd()
21830 
 
21831 
  def validate(self):
21832 
    return
21833 
 
21834 
 
21835 
  def __repr__(self):
21836 
    L = ['%s=%r' % (key, value)
21837 
      for key, value in self.__dict__.iteritems()]
21838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21839 
 
21840 
  def __eq__(self, other):
21841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21842 
 
21843 
  def __ne__(self, other):
21844 
    return not (self == other)
5067 varun.gupt 21845 
 
21846 
class getOrderIdsForStatus_args:
21847 
  """
21848 
  Attributes:
21849 
   - status
21850 
   - startDatetime
21851 
   - endDatetime
21852 
  """
21853 
 
21854 
  thrift_spec = (
21855 
    None, # 0
21856 
    (1, TType.I64, 'status', None, None, ), # 1
21857 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
21858 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
21859 
  )
21860 
 
21861 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
21862 
    self.status = status
21863 
    self.startDatetime = startDatetime
21864 
    self.endDatetime = endDatetime
21865 
 
21866 
  def read(self, iprot):
21867 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21868 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21869 
      return
21870 
    iprot.readStructBegin()
21871 
    while True:
21872 
      (fname, ftype, fid) = iprot.readFieldBegin()
21873 
      if ftype == TType.STOP:
21874 
        break
21875 
      if fid == 1:
21876 
        if ftype == TType.I64:
21877 
          self.status = iprot.readI64();
21878 
        else:
21879 
          iprot.skip(ftype)
21880 
      elif fid == 2:
21881 
        if ftype == TType.I64:
21882 
          self.startDatetime = iprot.readI64();
21883 
        else:
21884 
          iprot.skip(ftype)
21885 
      elif fid == 3:
21886 
        if ftype == TType.I64:
21887 
          self.endDatetime = iprot.readI64();
21888 
        else:
21889 
          iprot.skip(ftype)
21890 
      else:
21891 
        iprot.skip(ftype)
21892 
      iprot.readFieldEnd()
21893 
    iprot.readStructEnd()
21894 
 
21895 
  def write(self, oprot):
21896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21898 
      return
21899 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
21900 
    if self.status is not None:
21901 
      oprot.writeFieldBegin('status', TType.I64, 1)
21902 
      oprot.writeI64(self.status)
21903 
      oprot.writeFieldEnd()
21904 
    if self.startDatetime is not None:
21905 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
21906 
      oprot.writeI64(self.startDatetime)
21907 
      oprot.writeFieldEnd()
21908 
    if self.endDatetime is not None:
21909 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
21910 
      oprot.writeI64(self.endDatetime)
21911 
      oprot.writeFieldEnd()
21912 
    oprot.writeFieldStop()
21913 
    oprot.writeStructEnd()
21914 
 
21915 
  def validate(self):
21916 
    return
21917 
 
21918 
 
21919 
  def __repr__(self):
21920 
    L = ['%s=%r' % (key, value)
21921 
      for key, value in self.__dict__.iteritems()]
21922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21923 
 
21924 
  def __eq__(self, other):
21925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21926 
 
21927 
  def __ne__(self, other):
21928 
    return not (self == other)
21929 
 
21930 
class getOrderIdsForStatus_result:
21931 
  """
21932 
  Attributes:
21933 
   - success
21934 
   - ex
21935 
  """
21936 
 
21937 
  thrift_spec = (
21938 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21939 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21940 
  )
21941 
 
21942 
  def __init__(self, success=None, ex=None,):
21943 
    self.success = success
21944 
    self.ex = ex
21945 
 
21946 
  def read(self, iprot):
21947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21949 
      return
21950 
    iprot.readStructBegin()
21951 
    while True:
21952 
      (fname, ftype, fid) = iprot.readFieldBegin()
21953 
      if ftype == TType.STOP:
21954 
        break
21955 
      if fid == 0:
21956 
        if ftype == TType.LIST:
21957 
          self.success = []
21958 
          (_etype520, _size517) = iprot.readListBegin()
21959 
          for _i521 in xrange(_size517):
21960 
            _elem522 = iprot.readI64();
21961 
            self.success.append(_elem522)
21962 
          iprot.readListEnd()
21963 
        else:
21964 
          iprot.skip(ftype)
21965 
      elif fid == 1:
21966 
        if ftype == TType.STRUCT:
21967 
          self.ex = TransactionServiceException()
21968 
          self.ex.read(iprot)
21969 
        else:
21970 
          iprot.skip(ftype)
21971 
      else:
21972 
        iprot.skip(ftype)
21973 
      iprot.readFieldEnd()
21974 
    iprot.readStructEnd()
21975 
 
21976 
  def write(self, oprot):
21977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21979 
      return
21980 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
21981 
    if self.success is not None:
21982 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21983 
      oprot.writeListBegin(TType.I64, len(self.success))
21984 
      for iter523 in self.success:
21985 
        oprot.writeI64(iter523)
21986 
      oprot.writeListEnd()
21987 
      oprot.writeFieldEnd()
21988 
    if self.ex is not None:
21989 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21990 
      self.ex.write(oprot)
21991 
      oprot.writeFieldEnd()
21992 
    oprot.writeFieldStop()
21993 
    oprot.writeStructEnd()
21994 
 
21995 
  def validate(self):
21996 
    return
21997 
 
21998 
 
21999 
  def __repr__(self):
22000 
    L = ['%s=%r' % (key, value)
22001 
      for key, value in self.__dict__.iteritems()]
22002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22003 
 
22004 
  def __eq__(self, other):
22005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22006 
 
22007 
  def __ne__(self, other):
22008 
    return not (self == other)
5099 varun.gupt 22009 
 
22010 
class updateOrderAsPaidToVendor_args:
22011 
  """
22012 
  Attributes:
22013 
   - orderId
22014 
  """
22015 
 
22016 
  thrift_spec = (
22017 
    None, # 0
22018 
    (1, TType.I64, 'orderId', None, None, ), # 1
22019 
  )
22020 
 
22021 
  def __init__(self, orderId=None,):
22022 
    self.orderId = orderId
22023 
 
22024 
  def read(self, iprot):
22025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22027 
      return
22028 
    iprot.readStructBegin()
22029 
    while True:
22030 
      (fname, ftype, fid) = iprot.readFieldBegin()
22031 
      if ftype == TType.STOP:
22032 
        break
22033 
      if fid == 1:
22034 
        if ftype == TType.I64:
22035 
          self.orderId = iprot.readI64();
22036 
        else:
22037 
          iprot.skip(ftype)
22038 
      else:
22039 
        iprot.skip(ftype)
22040 
      iprot.readFieldEnd()
22041 
    iprot.readStructEnd()
22042 
 
22043 
  def write(self, oprot):
22044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22046 
      return
22047 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
22048 
    if self.orderId is not None:
22049 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22050 
      oprot.writeI64(self.orderId)
22051 
      oprot.writeFieldEnd()
22052 
    oprot.writeFieldStop()
22053 
    oprot.writeStructEnd()
22054 
 
22055 
  def validate(self):
22056 
    return
22057 
 
22058 
 
22059 
  def __repr__(self):
22060 
    L = ['%s=%r' % (key, value)
22061 
      for key, value in self.__dict__.iteritems()]
22062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22063 
 
22064 
  def __eq__(self, other):
22065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22066 
 
22067 
  def __ne__(self, other):
22068 
    return not (self == other)
22069 
 
22070 
class updateOrderAsPaidToVendor_result:
22071 
  """
22072 
  Attributes:
22073 
   - ex
22074 
  """
22075 
 
22076 
  thrift_spec = (
22077 
    None, # 0
22078 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22079 
  )
22080 
 
22081 
  def __init__(self, ex=None,):
22082 
    self.ex = ex
22083 
 
22084 
  def read(self, iprot):
22085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22087 
      return
22088 
    iprot.readStructBegin()
22089 
    while True:
22090 
      (fname, ftype, fid) = iprot.readFieldBegin()
22091 
      if ftype == TType.STOP:
22092 
        break
22093 
      if fid == 1:
22094 
        if ftype == TType.STRUCT:
22095 
          self.ex = TransactionServiceException()
22096 
          self.ex.read(iprot)
22097 
        else:
22098 
          iprot.skip(ftype)
22099 
      else:
22100 
        iprot.skip(ftype)
22101 
      iprot.readFieldEnd()
22102 
    iprot.readStructEnd()
22103 
 
22104 
  def write(self, oprot):
22105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22107 
      return
22108 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
22109 
    if self.ex is not None:
22110 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22111 
      self.ex.write(oprot)
22112 
      oprot.writeFieldEnd()
22113 
    oprot.writeFieldStop()
22114 
    oprot.writeStructEnd()
22115 
 
22116 
  def validate(self):
22117 
    return
22118 
 
22119 
 
22120 
  def __repr__(self):
22121 
    L = ['%s=%r' % (key, value)
22122 
      for key, value in self.__dict__.iteritems()]
22123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22124 
 
22125 
  def __eq__(self, other):
22126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22127 
 
22128 
  def __ne__(self, other):
22129 
    return not (self == other)