Subversion Repositories SmartDukaan

Rev

Rev 5189 | Rev 5238 | 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 
 
5208 varun.gupt 1132 
  def getRefundedOrdersMarkedPaid(self, ):
1133 
    pass
5099 varun.gupt 1134 
 
5208 varun.gupt 1135 
 
3376 rajveer 1136 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1137 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1138 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1139 
 
1140 
  def createTransaction(self, transaction):
1141 
    """
1142 
    Parameters:
1143 
     - transaction
1144 
    """
1145 
    self.send_createTransaction(transaction)
132 ashish 1146 
    return self.recv_createTransaction()
94 ashish 1147 
 
1148 
  def send_createTransaction(self, transaction):
1149 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1150 
    args = createTransaction_args()
1151 
    args.transaction = transaction
1152 
    args.write(self._oprot)
1153 
    self._oprot.writeMessageEnd()
1154 
    self._oprot.trans.flush()
1155 
 
1156 
  def recv_createTransaction(self, ):
1157 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1158 
    if mtype == TMessageType.EXCEPTION:
1159 
      x = TApplicationException()
1160 
      x.read(self._iprot)
1161 
      self._iprot.readMessageEnd()
1162 
      raise x
1163 
    result = createTransaction_result()
1164 
    result.read(self._iprot)
1165 
    self._iprot.readMessageEnd()
3431 rajveer 1166 
    if result.success is not None:
132 ashish 1167 
      return result.success
3431 rajveer 1168 
    if result.ex is not None:
94 ashish 1169 
      raise result.ex
132 ashish 1170 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1171 
 
1172 
  def getTransaction(self, id):
1173 
    """
1174 
    Parameters:
1175 
     - id
1176 
    """
1177 
    self.send_getTransaction(id)
1178 
    return self.recv_getTransaction()
1179 
 
1180 
  def send_getTransaction(self, id):
1181 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1182 
    args = getTransaction_args()
1183 
    args.id = id
1184 
    args.write(self._oprot)
1185 
    self._oprot.writeMessageEnd()
1186 
    self._oprot.trans.flush()
1187 
 
1188 
  def recv_getTransaction(self, ):
1189 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1190 
    if mtype == TMessageType.EXCEPTION:
1191 
      x = TApplicationException()
1192 
      x.read(self._iprot)
1193 
      self._iprot.readMessageEnd()
1194 
      raise x
1195 
    result = getTransaction_result()
1196 
    result.read(self._iprot)
1197 
    self._iprot.readMessageEnd()
3431 rajveer 1198 
    if result.success is not None:
94 ashish 1199 
      return result.success
3431 rajveer 1200 
    if result.ex is not None:
94 ashish 1201 
      raise result.ex
1202 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1203 
 
1204 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1205 
    """
1206 
    Parameters:
1207 
     - customerId
1208 
     - from_date
1209 
     - to_date
1210 
     - status
1211 
    """
1212 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1213 
    return self.recv_getTransactionsForCustomer()
1214 
 
1215 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1216 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1217 
    args = getTransactionsForCustomer_args()
1218 
    args.customerId = customerId
1219 
    args.from_date = from_date
1220 
    args.to_date = to_date
1221 
    args.status = status
1222 
    args.write(self._oprot)
1223 
    self._oprot.writeMessageEnd()
1224 
    self._oprot.trans.flush()
1225 
 
1226 
  def recv_getTransactionsForCustomer(self, ):
1227 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1228 
    if mtype == TMessageType.EXCEPTION:
1229 
      x = TApplicationException()
1230 
      x.read(self._iprot)
1231 
      self._iprot.readMessageEnd()
1232 
      raise x
1233 
    result = getTransactionsForCustomer_result()
1234 
    result.read(self._iprot)
1235 
    self._iprot.readMessageEnd()
3431 rajveer 1236 
    if result.success is not None:
94 ashish 1237 
      return result.success
3431 rajveer 1238 
    if result.ex is not None:
94 ashish 1239 
      raise result.ex
1240 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1241 
 
132 ashish 1242 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1243 
    """
1244 
    Parameters:
1245 
     - shoppingCartId
1246 
    """
1247 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1248 
    return self.recv_getTransactionsForShoppingCartId()
1249 
 
1250 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1251 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1252 
    args = getTransactionsForShoppingCartId_args()
1253 
    args.shoppingCartId = shoppingCartId
1254 
    args.write(self._oprot)
1255 
    self._oprot.writeMessageEnd()
1256 
    self._oprot.trans.flush()
1257 
 
1258 
  def recv_getTransactionsForShoppingCartId(self, ):
1259 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1260 
    if mtype == TMessageType.EXCEPTION:
1261 
      x = TApplicationException()
1262 
      x.read(self._iprot)
1263 
      self._iprot.readMessageEnd()
1264 
      raise x
1265 
    result = getTransactionsForShoppingCartId_result()
1266 
    result.read(self._iprot)
1267 
    self._iprot.readMessageEnd()
3431 rajveer 1268 
    if result.success is not None:
132 ashish 1269 
      return result.success
3431 rajveer 1270 
    if result.ex is not None:
132 ashish 1271 
      raise result.ex
1272 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1273 
 
94 ashish 1274 
  def getTransactionStatus(self, transactionId):
1275 
    """
1276 
    Parameters:
1277 
     - transactionId
1278 
    """
1279 
    self.send_getTransactionStatus(transactionId)
1280 
    return self.recv_getTransactionStatus()
1281 
 
1282 
  def send_getTransactionStatus(self, transactionId):
1283 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1284 
    args = getTransactionStatus_args()
1285 
    args.transactionId = transactionId
1286 
    args.write(self._oprot)
1287 
    self._oprot.writeMessageEnd()
1288 
    self._oprot.trans.flush()
1289 
 
1290 
  def recv_getTransactionStatus(self, ):
1291 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1292 
    if mtype == TMessageType.EXCEPTION:
1293 
      x = TApplicationException()
1294 
      x.read(self._iprot)
1295 
      self._iprot.readMessageEnd()
1296 
      raise x
1297 
    result = getTransactionStatus_result()
1298 
    result.read(self._iprot)
1299 
    self._iprot.readMessageEnd()
3431 rajveer 1300 
    if result.success is not None:
94 ashish 1301 
      return result.success
3431 rajveer 1302 
    if result.ex is not None:
94 ashish 1303 
      raise result.ex
1304 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1305 
 
1306 
  def changeTransactionStatus(self, transactionId, status, description):
1307 
    """
1308 
    Parameters:
1309 
     - transactionId
1310 
     - status
1311 
     - description
1312 
    """
1313 
    self.send_changeTransactionStatus(transactionId, status, description)
1314 
    return self.recv_changeTransactionStatus()
1315 
 
1316 
  def send_changeTransactionStatus(self, transactionId, status, description):
1317 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1318 
    args = changeTransactionStatus_args()
1319 
    args.transactionId = transactionId
1320 
    args.status = status
1321 
    args.description = description
1322 
    args.write(self._oprot)
1323 
    self._oprot.writeMessageEnd()
1324 
    self._oprot.trans.flush()
1325 
 
1326 
  def recv_changeTransactionStatus(self, ):
1327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1328 
    if mtype == TMessageType.EXCEPTION:
1329 
      x = TApplicationException()
1330 
      x.read(self._iprot)
1331 
      self._iprot.readMessageEnd()
1332 
      raise x
1333 
    result = changeTransactionStatus_result()
1334 
    result.read(self._iprot)
1335 
    self._iprot.readMessageEnd()
3431 rajveer 1336 
    if result.success is not None:
94 ashish 1337 
      return result.success
3431 rajveer 1338 
    if result.ex is not None:
94 ashish 1339 
      raise result.ex
1340 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1341 
 
1398 varun.gupt 1342 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1343 
    """
1344 
    Parameters:
1345 
     - transactionId
1346 
    """
1398 varun.gupt 1347 
    self.send_enqueueTransactionInfoEmail(transactionId)
1348 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1349 
 
1398 varun.gupt 1350 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1351 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1352 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1353 
    args.transactionId = transactionId
1354 
    args.write(self._oprot)
1355 
    self._oprot.writeMessageEnd()
1356 
    self._oprot.trans.flush()
1357 
 
1398 varun.gupt 1358 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1359 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1360 
    if mtype == TMessageType.EXCEPTION:
1361 
      x = TApplicationException()
1362 
      x.read(self._iprot)
1363 
      self._iprot.readMessageEnd()
1364 
      raise x
1398 varun.gupt 1365 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1366 
    result.read(self._iprot)
1367 
    self._iprot.readMessageEnd()
3431 rajveer 1368 
    if result.success is not None:
1382 varun.gupt 1369 
      return result.success
3431 rajveer 1370 
    if result.ex is not None:
1382 varun.gupt 1371 
      raise result.ex
1398 varun.gupt 1372 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1373 
 
4801 anupam.sin 1374 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1375 
    """
1376 
    Parameters:
4801 anupam.sin 1377 
     - statuses
483 rajveer 1378 
     - from_date
1379 
     - to_date
1380 
     - warehouse_id
94 ashish 1381 
    """
4801 anupam.sin 1382 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1383 
    return self.recv_getAllOrders()
94 ashish 1384 
 
4801 anupam.sin 1385 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1386 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1387 
    args = getAllOrders_args()
4801 anupam.sin 1388 
    args.statuses = statuses
483 rajveer 1389 
    args.from_date = from_date
1390 
    args.to_date = to_date
1391 
    args.warehouse_id = warehouse_id
94 ashish 1392 
    args.write(self._oprot)
1393 
    self._oprot.writeMessageEnd()
1394 
    self._oprot.trans.flush()
1395 
 
483 rajveer 1396 
  def recv_getAllOrders(self, ):
94 ashish 1397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1398 
    if mtype == TMessageType.EXCEPTION:
1399 
      x = TApplicationException()
1400 
      x.read(self._iprot)
1401 
      self._iprot.readMessageEnd()
1402 
      raise x
483 rajveer 1403 
    result = getAllOrders_result()
94 ashish 1404 
    result.read(self._iprot)
1405 
    self._iprot.readMessageEnd()
3431 rajveer 1406 
    if result.success is not None:
94 ashish 1407 
      return result.success
3431 rajveer 1408 
    if result.ex is not None:
94 ashish 1409 
      raise result.ex
483 rajveer 1410 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1411 
 
4133 chandransh 1412 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1413 
    """
1414 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1415 
    Pass the status as null and the limit as 0 to ignore them.
1416 
 
1417 
    Parameters:
1418 
     - statuses
1419 
     - offset
1420 
     - limit
1421 
     - warehouse_id
1422 
    """
1423 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1424 
    return self.recv_getOrdersInBatch()
1425 
 
1426 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1427 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1428 
    args = getOrdersInBatch_args()
1429 
    args.statuses = statuses
1430 
    args.offset = offset
1431 
    args.limit = limit
1432 
    args.warehouse_id = warehouse_id
1433 
    args.write(self._oprot)
1434 
    self._oprot.writeMessageEnd()
1435 
    self._oprot.trans.flush()
1436 
 
1437 
  def recv_getOrdersInBatch(self, ):
1438 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1439 
    if mtype == TMessageType.EXCEPTION:
1440 
      x = TApplicationException()
1441 
      x.read(self._iprot)
1442 
      self._iprot.readMessageEnd()
1443 
      raise x
1444 
    result = getOrdersInBatch_result()
1445 
    result.read(self._iprot)
1446 
    self._iprot.readMessageEnd()
1447 
    if result.success is not None:
1448 
      return result.success
1449 
    if result.ex is not None:
1450 
      raise result.ex
1451 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1452 
 
1453 
  def getOrderCount(self, statuses, warehouseId):
1454 
    """
1455 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1456 
 
1457 
    Parameters:
1458 
     - statuses
1459 
     - warehouseId
1460 
    """
1461 
    self.send_getOrderCount(statuses, warehouseId)
1462 
    return self.recv_getOrderCount()
1463 
 
1464 
  def send_getOrderCount(self, statuses, warehouseId):
1465 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1466 
    args = getOrderCount_args()
1467 
    args.statuses = statuses
1468 
    args.warehouseId = warehouseId
1469 
    args.write(self._oprot)
1470 
    self._oprot.writeMessageEnd()
1471 
    self._oprot.trans.flush()
1472 
 
1473 
  def recv_getOrderCount(self, ):
1474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1475 
    if mtype == TMessageType.EXCEPTION:
1476 
      x = TApplicationException()
1477 
      x.read(self._iprot)
1478 
      self._iprot.readMessageEnd()
1479 
      raise x
1480 
    result = getOrderCount_result()
1481 
    result.read(self._iprot)
1482 
    self._iprot.readMessageEnd()
1483 
    if result.success is not None:
1484 
      return result.success
1485 
    if result.ex is not None:
1486 
      raise result.ex
1487 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1488 
 
999 varun.gupt 1489 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1490 
    """
1132 chandransh 1491 
    Returns orders within a range of their billing dates
3431 rajveer 1492 
 
999 varun.gupt 1493 
    Parameters:
1494 
     - status
1495 
     - start_billing_date
1496 
     - end_billing_date
1497 
     - warehouse_id
1498 
    """
1499 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1500 
    return self.recv_getOrdersByBillingDate()
1501 
 
1502 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1503 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1504 
    args = getOrdersByBillingDate_args()
1505 
    args.status = status
1506 
    args.start_billing_date = start_billing_date
1507 
    args.end_billing_date = end_billing_date
1508 
    args.warehouse_id = warehouse_id
1509 
    args.write(self._oprot)
1510 
    self._oprot.writeMessageEnd()
1511 
    self._oprot.trans.flush()
1512 
 
1513 
  def recv_getOrdersByBillingDate(self, ):
1514 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1515 
    if mtype == TMessageType.EXCEPTION:
1516 
      x = TApplicationException()
1517 
      x.read(self._iprot)
1518 
      self._iprot.readMessageEnd()
1519 
      raise x
1520 
    result = getOrdersByBillingDate_result()
1521 
    result.read(self._iprot)
1522 
    self._iprot.readMessageEnd()
3431 rajveer 1523 
    if result.success is not None:
999 varun.gupt 1524 
      return result.success
3431 rajveer 1525 
    if result.ex is not None:
999 varun.gupt 1526 
      raise result.ex
1527 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1528 
 
3451 chandransh 1529 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1530 
    """
1531 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1532 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1533 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1534 
 
3427 chandransh 1535 
    Parameters:
1536 
     - fromShippingDate
1537 
     - toShippingDate
1538 
     - providerId
1539 
     - warehouseId
3451 chandransh 1540 
     - cod
3427 chandransh 1541 
    """
3451 chandransh 1542 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1543 
    return self.recv_getOrdersByShippingDate()
1544 
 
3451 chandransh 1545 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1546 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1547 
    args = getOrdersByShippingDate_args()
1548 
    args.fromShippingDate = fromShippingDate
1549 
    args.toShippingDate = toShippingDate
1550 
    args.providerId = providerId
1551 
    args.warehouseId = warehouseId
3451 chandransh 1552 
    args.cod = cod
3427 chandransh 1553 
    args.write(self._oprot)
1554 
    self._oprot.writeMessageEnd()
1555 
    self._oprot.trans.flush()
1556 
 
1557 
  def recv_getOrdersByShippingDate(self, ):
1558 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1559 
    if mtype == TMessageType.EXCEPTION:
1560 
      x = TApplicationException()
1561 
      x.read(self._iprot)
1562 
      self._iprot.readMessageEnd()
1563 
      raise x
1564 
    result = getOrdersByShippingDate_result()
1565 
    result.read(self._iprot)
1566 
    self._iprot.readMessageEnd()
3431 rajveer 1567 
    if result.success is not None:
3427 chandransh 1568 
      return result.success
3431 rajveer 1569 
    if result.ex is not None:
3427 chandransh 1570 
      raise result.ex
1571 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1572 
 
1382 varun.gupt 1573 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1574 
    """
1575 
    Returns order ids for orders which can be returned
3431 rajveer 1576 
 
1382 varun.gupt 1577 
    Parameters:
1578 
     - customer_id
1579 
     - limit
1580 
    """
1581 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1582 
    return self.recv_getReturnableOrdersForCustomer()
1583 
 
1584 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1585 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1586 
    args = getReturnableOrdersForCustomer_args()
1587 
    args.customer_id = customer_id
1588 
    args.limit = limit
1589 
    args.write(self._oprot)
1590 
    self._oprot.writeMessageEnd()
1591 
    self._oprot.trans.flush()
1592 
 
1593 
  def recv_getReturnableOrdersForCustomer(self, ):
1594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1595 
    if mtype == TMessageType.EXCEPTION:
1596 
      x = TApplicationException()
1597 
      x.read(self._iprot)
1598 
      self._iprot.readMessageEnd()
1599 
      raise x
1600 
    result = getReturnableOrdersForCustomer_result()
1601 
    result.read(self._iprot)
1602 
    self._iprot.readMessageEnd()
3431 rajveer 1603 
    if result.success is not None:
1382 varun.gupt 1604 
      return result.success
3431 rajveer 1605 
    if result.ex is not None:
1382 varun.gupt 1606 
      raise result.ex
1607 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1608 
 
1609 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1610 
    """
1611 
    Returns order ids for orders which can be cancelled
3431 rajveer 1612 
 
1382 varun.gupt 1613 
    Parameters:
1614 
     - customer_id
1615 
     - limit
1616 
    """
1617 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1618 
    return self.recv_getCancellableOrdersForCustomer()
1619 
 
1620 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1621 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1622 
    args = getCancellableOrdersForCustomer_args()
1623 
    args.customer_id = customer_id
1624 
    args.limit = limit
1625 
    args.write(self._oprot)
1626 
    self._oprot.writeMessageEnd()
1627 
    self._oprot.trans.flush()
1628 
 
1629 
  def recv_getCancellableOrdersForCustomer(self, ):
1630 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1631 
    if mtype == TMessageType.EXCEPTION:
1632 
      x = TApplicationException()
1633 
      x.read(self._iprot)
1634 
      self._iprot.readMessageEnd()
1635 
      raise x
1636 
    result = getCancellableOrdersForCustomer_result()
1637 
    result.read(self._iprot)
1638 
    self._iprot.readMessageEnd()
3431 rajveer 1639 
    if result.success is not None:
1382 varun.gupt 1640 
      return result.success
3431 rajveer 1641 
    if result.ex is not None:
1382 varun.gupt 1642 
      raise result.ex
1643 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1644 
 
483 rajveer 1645 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1646 
    """
1647 
    Parameters:
483 rajveer 1648 
     - orderId
1649 
     - status
1650 
     - description
94 ashish 1651 
    """
483 rajveer 1652 
    self.send_changeOrderStatus(orderId, status, description)
1653 
    return self.recv_changeOrderStatus()
94 ashish 1654 
 
483 rajveer 1655 
  def send_changeOrderStatus(self, orderId, status, description):
1656 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1657 
    args = changeOrderStatus_args()
1658 
    args.orderId = orderId
1659 
    args.status = status
1660 
    args.description = description
94 ashish 1661 
    args.write(self._oprot)
1662 
    self._oprot.writeMessageEnd()
1663 
    self._oprot.trans.flush()
1664 
 
483 rajveer 1665 
  def recv_changeOrderStatus(self, ):
94 ashish 1666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1667 
    if mtype == TMessageType.EXCEPTION:
1668 
      x = TApplicationException()
1669 
      x.read(self._iprot)
1670 
      self._iprot.readMessageEnd()
1671 
      raise x
483 rajveer 1672 
    result = changeOrderStatus_result()
94 ashish 1673 
    result.read(self._iprot)
1674 
    self._iprot.readMessageEnd()
3431 rajveer 1675 
    if result.success is not None:
94 ashish 1676 
      return result.success
3431 rajveer 1677 
    if result.ex is not None:
94 ashish 1678 
      raise result.ex
483 rajveer 1679 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1680 
 
1528 ankur.sing 1681 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1682 
    """
1528 ankur.sing 1683 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1684 
    only user who owns the transaction can view its order details.
3431 rajveer 1685 
 
94 ashish 1686 
    Parameters:
1687 
     - transactionId
1528 ankur.sing 1688 
     - customerId
94 ashish 1689 
    """
1528 ankur.sing 1690 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1691 
    return self.recv_getOrdersForTransaction()
94 ashish 1692 
 
1528 ankur.sing 1693 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1694 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1695 
    args = getOrdersForTransaction_args()
94 ashish 1696 
    args.transactionId = transactionId
1528 ankur.sing 1697 
    args.customerId = customerId
94 ashish 1698 
    args.write(self._oprot)
1699 
    self._oprot.writeMessageEnd()
1700 
    self._oprot.trans.flush()
1701 
 
483 rajveer 1702 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1703 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1704 
    if mtype == TMessageType.EXCEPTION:
1705 
      x = TApplicationException()
1706 
      x.read(self._iprot)
1707 
      self._iprot.readMessageEnd()
1708 
      raise x
483 rajveer 1709 
    result = getOrdersForTransaction_result()
94 ashish 1710 
    result.read(self._iprot)
1711 
    self._iprot.readMessageEnd()
3431 rajveer 1712 
    if result.success is not None:
94 ashish 1713 
      return result.success
3431 rajveer 1714 
    if result.ex is not None:
94 ashish 1715 
      raise result.ex
483 rajveer 1716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1717 
 
3014 chandransh 1718 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1719 
    """
3014 chandransh 1720 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1721 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1722 
 
94 ashish 1723 
    Parameters:
483 rajveer 1724 
     - customerId
1725 
     - from_date
1726 
     - to_date
3014 chandransh 1727 
     - statuses
94 ashish 1728 
    """
3014 chandransh 1729 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1730 
    return self.recv_getOrdersForCustomer()
94 ashish 1731 
 
3014 chandransh 1732 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1733 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1734 
    args = getOrdersForCustomer_args()
1735 
    args.customerId = customerId
1736 
    args.from_date = from_date
1737 
    args.to_date = to_date
3014 chandransh 1738 
    args.statuses = statuses
94 ashish 1739 
    args.write(self._oprot)
1740 
    self._oprot.writeMessageEnd()
1741 
    self._oprot.trans.flush()
1742 
 
483 rajveer 1743 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1745 
    if mtype == TMessageType.EXCEPTION:
1746 
      x = TApplicationException()
1747 
      x.read(self._iprot)
1748 
      self._iprot.readMessageEnd()
1749 
      raise x
483 rajveer 1750 
    result = getOrdersForCustomer_result()
94 ashish 1751 
    result.read(self._iprot)
1752 
    self._iprot.readMessageEnd()
3431 rajveer 1753 
    if result.success is not None:
94 ashish 1754 
      return result.success
3431 rajveer 1755 
    if result.ex is not None:
94 ashish 1756 
      raise result.ex
483 rajveer 1757 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1758 
 
483 rajveer 1759 
  def createOrder(self, order):
94 ashish 1760 
    """
1761 
    Parameters:
483 rajveer 1762 
     - order
94 ashish 1763 
    """
483 rajveer 1764 
    self.send_createOrder(order)
1765 
    return self.recv_createOrder()
94 ashish 1766 
 
483 rajveer 1767 
  def send_createOrder(self, order):
1768 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1769 
    args = createOrder_args()
1770 
    args.order = order
94 ashish 1771 
    args.write(self._oprot)
1772 
    self._oprot.writeMessageEnd()
1773 
    self._oprot.trans.flush()
1774 
 
483 rajveer 1775 
  def recv_createOrder(self, ):
94 ashish 1776 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1777 
    if mtype == TMessageType.EXCEPTION:
1778 
      x = TApplicationException()
1779 
      x.read(self._iprot)
1780 
      self._iprot.readMessageEnd()
1781 
      raise x
483 rajveer 1782 
    result = createOrder_result()
94 ashish 1783 
    result.read(self._iprot)
1784 
    self._iprot.readMessageEnd()
3431 rajveer 1785 
    if result.success is not None:
94 ashish 1786 
      return result.success
3431 rajveer 1787 
    if result.ex is not None:
94 ashish 1788 
      raise result.ex
483 rajveer 1789 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1790 
 
483 rajveer 1791 
  def getOrder(self, id):
94 ashish 1792 
    """
1793 
    Parameters:
483 rajveer 1794 
     - id
94 ashish 1795 
    """
483 rajveer 1796 
    self.send_getOrder(id)
1797 
    return self.recv_getOrder()
94 ashish 1798 
 
483 rajveer 1799 
  def send_getOrder(self, id):
1800 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1801 
    args = getOrder_args()
1802 
    args.id = id
94 ashish 1803 
    args.write(self._oprot)
1804 
    self._oprot.writeMessageEnd()
1805 
    self._oprot.trans.flush()
1806 
 
483 rajveer 1807 
  def recv_getOrder(self, ):
94 ashish 1808 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1809 
    if mtype == TMessageType.EXCEPTION:
1810 
      x = TApplicationException()
1811 
      x.read(self._iprot)
1812 
      self._iprot.readMessageEnd()
1813 
      raise x
483 rajveer 1814 
    result = getOrder_result()
94 ashish 1815 
    result.read(self._iprot)
1816 
    self._iprot.readMessageEnd()
3431 rajveer 1817 
    if result.success is not None:
94 ashish 1818 
      return result.success
3431 rajveer 1819 
    if result.ex is not None:
94 ashish 1820 
      raise result.ex
483 rajveer 1821 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1822 
 
483 rajveer 1823 
  def getLineItemsForOrder(self, orderId):
94 ashish 1824 
    """
1825 
    Parameters:
483 rajveer 1826 
     - orderId
94 ashish 1827 
    """
483 rajveer 1828 
    self.send_getLineItemsForOrder(orderId)
1829 
    return self.recv_getLineItemsForOrder()
94 ashish 1830 
 
483 rajveer 1831 
  def send_getLineItemsForOrder(self, orderId):
1832 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1833 
    args = getLineItemsForOrder_args()
1834 
    args.orderId = orderId
94 ashish 1835 
    args.write(self._oprot)
1836 
    self._oprot.writeMessageEnd()
1837 
    self._oprot.trans.flush()
1838 
 
483 rajveer 1839 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1840 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1841 
    if mtype == TMessageType.EXCEPTION:
1842 
      x = TApplicationException()
1843 
      x.read(self._iprot)
1844 
      self._iprot.readMessageEnd()
1845 
      raise x
483 rajveer 1846 
    result = getLineItemsForOrder_result()
94 ashish 1847 
    result.read(self._iprot)
1848 
    self._iprot.readMessageEnd()
3431 rajveer 1849 
    if result.success is not None:
94 ashish 1850 
      return result.success
3431 rajveer 1851 
    if result.ex is not None:
94 ashish 1852 
      raise result.ex
483 rajveer 1853 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1854 
 
4999 phani.kuma 1855 
  def getOrderList(self, order_ids):
1856 
    """
1857 
    Parameters:
1858 
     - order_ids
1859 
    """
1860 
    self.send_getOrderList(order_ids)
1861 
    return self.recv_getOrderList()
1862 
 
1863 
  def send_getOrderList(self, order_ids):
1864 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
1865 
    args = getOrderList_args()
1866 
    args.order_ids = order_ids
1867 
    args.write(self._oprot)
1868 
    self._oprot.writeMessageEnd()
1869 
    self._oprot.trans.flush()
1870 
 
1871 
  def recv_getOrderList(self, ):
1872 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1873 
    if mtype == TMessageType.EXCEPTION:
1874 
      x = TApplicationException()
1875 
      x.read(self._iprot)
1876 
      self._iprot.readMessageEnd()
1877 
      raise x
1878 
    result = getOrderList_result()
1879 
    result.read(self._iprot)
1880 
    self._iprot.readMessageEnd()
1881 
    if result.success is not None:
1882 
      return result.success
1883 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
1884 
 
1528 ankur.sing 1885 
  def getOrderForCustomer(self, orderId, customerId):
1886 
    """
1887 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1888 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 1889 
 
1528 ankur.sing 1890 
    Parameters:
1891 
     - orderId
1892 
     - customerId
1893 
    """
1894 
    self.send_getOrderForCustomer(orderId, customerId)
1895 
    return self.recv_getOrderForCustomer()
1896 
 
1897 
  def send_getOrderForCustomer(self, orderId, customerId):
1898 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1899 
    args = getOrderForCustomer_args()
1900 
    args.orderId = orderId
1901 
    args.customerId = customerId
1902 
    args.write(self._oprot)
1903 
    self._oprot.writeMessageEnd()
1904 
    self._oprot.trans.flush()
1905 
 
1906 
  def recv_getOrderForCustomer(self, ):
1907 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1908 
    if mtype == TMessageType.EXCEPTION:
1909 
      x = TApplicationException()
1910 
      x.read(self._iprot)
1911 
      self._iprot.readMessageEnd()
1912 
      raise x
1913 
    result = getOrderForCustomer_result()
1914 
    result.read(self._iprot)
1915 
    self._iprot.readMessageEnd()
3431 rajveer 1916 
    if result.success is not None:
1528 ankur.sing 1917 
      return result.success
3431 rajveer 1918 
    if result.ex is not None:
1528 ankur.sing 1919 
      raise result.ex
1920 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1921 
 
4444 rajveer 1922 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1923 
    """
1924 
    Parameters:
4394 rajveer 1925 
     - type
4444 rajveer 1926 
     - warehouseId
4394 rajveer 1927 
     - status
1928 
     - timestamp
3064 chandransh 1929 
    """
4444 rajveer 1930 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 1931 
    return self.recv_getAlerts()
1932 
 
4444 rajveer 1933 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 1934 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1935 
    args = getAlerts_args()
4394 rajveer 1936 
    args.type = type
4444 rajveer 1937 
    args.warehouseId = warehouseId
4394 rajveer 1938 
    args.status = status
1939 
    args.timestamp = timestamp
3064 chandransh 1940 
    args.write(self._oprot)
1941 
    self._oprot.writeMessageEnd()
1942 
    self._oprot.trans.flush()
1943 
 
1944 
  def recv_getAlerts(self, ):
1945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1946 
    if mtype == TMessageType.EXCEPTION:
1947 
      x = TApplicationException()
1948 
      x.read(self._iprot)
1949 
      self._iprot.readMessageEnd()
1950 
      raise x
1951 
    result = getAlerts_result()
1952 
    result.read(self._iprot)
1953 
    self._iprot.readMessageEnd()
3431 rajveer 1954 
    if result.success is not None:
3064 chandransh 1955 
      return result.success
1956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1957 
 
4444 rajveer 1958 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 1959 
    """
1960 
    Parameters:
1961 
     - type
4444 rajveer 1962 
     - warehouseId
4394 rajveer 1963 
     - description
3064 chandransh 1964 
    """
4444 rajveer 1965 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 1966 
    self.recv_addAlert()
3064 chandransh 1967 
 
4444 rajveer 1968 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 1969 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
1970 
    args = addAlert_args()
3064 chandransh 1971 
    args.type = type
4444 rajveer 1972 
    args.warehouseId = warehouseId
4394 rajveer 1973 
    args.description = description
3064 chandransh 1974 
    args.write(self._oprot)
1975 
    self._oprot.writeMessageEnd()
1976 
    self._oprot.trans.flush()
1977 
 
4394 rajveer 1978 
  def recv_addAlert(self, ):
3064 chandransh 1979 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1980 
    if mtype == TMessageType.EXCEPTION:
1981 
      x = TApplicationException()
1982 
      x.read(self._iprot)
1983 
      self._iprot.readMessageEnd()
1984 
      raise x
4394 rajveer 1985 
    result = addAlert_result()
3064 chandransh 1986 
    result.read(self._iprot)
1987 
    self._iprot.readMessageEnd()
1988 
    return
1989 
 
4444 rajveer 1990 
  def markAlertsAsSeen(self, warehouseId):
1991 
    """
1992 
    Parameters:
1993 
     - warehouseId
1994 
    """
1995 
    self.send_markAlertsAsSeen(warehouseId)
1996 
    self.recv_markAlertsAsSeen()
1997 
 
1998 
  def send_markAlertsAsSeen(self, warehouseId):
1999 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2000 
    args = markAlertsAsSeen_args()
2001 
    args.warehouseId = warehouseId
2002 
    args.write(self._oprot)
2003 
    self._oprot.writeMessageEnd()
2004 
    self._oprot.trans.flush()
2005 
 
2006 
  def recv_markAlertsAsSeen(self, ):
2007 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2008 
    if mtype == TMessageType.EXCEPTION:
2009 
      x = TApplicationException()
2010 
      x.read(self._iprot)
2011 
      self._iprot.readMessageEnd()
2012 
      raise x
2013 
    result = markAlertsAsSeen_result()
2014 
    result.read(self._iprot)
2015 
    self._iprot.readMessageEnd()
2016 
    return
2017 
 
3064 chandransh 2018 
  def getValidOrderCount(self, ):
2019 
    """
2020 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2021 
    """
2022 
    self.send_getValidOrderCount()
2023 
    return self.recv_getValidOrderCount()
2024 
 
2025 
  def send_getValidOrderCount(self, ):
2026 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2027 
    args = getValidOrderCount_args()
2028 
    args.write(self._oprot)
2029 
    self._oprot.writeMessageEnd()
2030 
    self._oprot.trans.flush()
2031 
 
2032 
  def recv_getValidOrderCount(self, ):
2033 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2034 
    if mtype == TMessageType.EXCEPTION:
2035 
      x = TApplicationException()
2036 
      x.read(self._iprot)
2037 
      self._iprot.readMessageEnd()
2038 
      raise x
2039 
    result = getValidOrderCount_result()
2040 
    result.read(self._iprot)
2041 
    self._iprot.readMessageEnd()
3431 rajveer 2042 
    if result.success is not None:
3064 chandransh 2043 
      return result.success
2044 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2045 
 
2046 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2047 
    """
2048 
    Returns the number of distinct customers who have done successful transactions
2049 
    """
2050 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2051 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2052 
 
2053 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2054 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2055 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2056 
    args.write(self._oprot)
2057 
    self._oprot.writeMessageEnd()
2058 
    self._oprot.trans.flush()
2059 
 
2060 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2061 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2062 
    if mtype == TMessageType.EXCEPTION:
2063 
      x = TApplicationException()
2064 
      x.read(self._iprot)
2065 
      self._iprot.readMessageEnd()
2066 
      raise x
2067 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2068 
    result.read(self._iprot)
2069 
    self._iprot.readMessageEnd()
3431 rajveer 2070 
    if result.success is not None:
3064 chandransh 2071 
      return result.success
2072 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2073 
 
2074 
  def getValidOrdersAmountRange(self, ):
2075 
    """
2076 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2077 
    List contains two values, first minimum amount and second maximum amount.
2078 
    """
2079 
    self.send_getValidOrdersAmountRange()
2080 
    return self.recv_getValidOrdersAmountRange()
2081 
 
2082 
  def send_getValidOrdersAmountRange(self, ):
2083 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2084 
    args = getValidOrdersAmountRange_args()
2085 
    args.write(self._oprot)
2086 
    self._oprot.writeMessageEnd()
2087 
    self._oprot.trans.flush()
2088 
 
2089 
  def recv_getValidOrdersAmountRange(self, ):
2090 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2091 
    if mtype == TMessageType.EXCEPTION:
2092 
      x = TApplicationException()
2093 
      x.read(self._iprot)
2094 
      self._iprot.readMessageEnd()
2095 
      raise x
2096 
    result = getValidOrdersAmountRange_result()
2097 
    result.read(self._iprot)
2098 
    self._iprot.readMessageEnd()
3431 rajveer 2099 
    if result.success is not None:
3064 chandransh 2100 
      return result.success
2101 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2102 
 
2103 
  def getValidOrders(self, limit):
2104 
    """
2105 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2106 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2107 
 
3064 chandransh 2108 
    Parameters:
2109 
     - limit
2110 
    """
2111 
    self.send_getValidOrders(limit)
2112 
    return self.recv_getValidOrders()
2113 
 
2114 
  def send_getValidOrders(self, limit):
2115 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2116 
    args = getValidOrders_args()
2117 
    args.limit = limit
2118 
    args.write(self._oprot)
2119 
    self._oprot.writeMessageEnd()
2120 
    self._oprot.trans.flush()
2121 
 
2122 
  def recv_getValidOrders(self, ):
2123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2124 
    if mtype == TMessageType.EXCEPTION:
2125 
      x = TApplicationException()
2126 
      x.read(self._iprot)
2127 
      self._iprot.readMessageEnd()
2128 
      raise x
2129 
    result = getValidOrders_result()
2130 
    result.read(self._iprot)
2131 
    self._iprot.readMessageEnd()
3431 rajveer 2132 
    if result.success is not None:
3064 chandransh 2133 
      return result.success
2134 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2135 
 
1220 chandransh 2136 
  def batchOrders(self, warehouseId):
2137 
    """
2138 
    Create a batch of all the pending orders for the given warehouse.
2139 
    The returned list is orderd by created_timestamp.
2140 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2141 
 
1220 chandransh 2142 
    Parameters:
2143 
     - warehouseId
2144 
    """
2145 
    self.send_batchOrders(warehouseId)
2146 
    return self.recv_batchOrders()
2147 
 
2148 
  def send_batchOrders(self, warehouseId):
2149 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2150 
    args = batchOrders_args()
2151 
    args.warehouseId = warehouseId
2152 
    args.write(self._oprot)
2153 
    self._oprot.writeMessageEnd()
2154 
    self._oprot.trans.flush()
2155 
 
2156 
  def recv_batchOrders(self, ):
2157 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2158 
    if mtype == TMessageType.EXCEPTION:
2159 
      x = TApplicationException()
2160 
      x.read(self._iprot)
2161 
      self._iprot.readMessageEnd()
2162 
      raise x
2163 
    result = batchOrders_result()
2164 
    result.read(self._iprot)
2165 
    self._iprot.readMessageEnd()
3431 rajveer 2166 
    if result.success is not None:
1220 chandransh 2167 
      return result.success
3431 rajveer 2168 
    if result.ex is not None:
1220 chandransh 2169 
      raise result.ex
2170 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2171 
 
1208 chandransh 2172 
  def markOrderAsOutOfStock(self, orderId):
2173 
    """
2174 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2175 
 
1208 chandransh 2176 
    Parameters:
2177 
     - orderId
2178 
    """
2179 
    self.send_markOrderAsOutOfStock(orderId)
2180 
    return self.recv_markOrderAsOutOfStock()
2181 
 
2182 
  def send_markOrderAsOutOfStock(self, orderId):
2183 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2184 
    args = markOrderAsOutOfStock_args()
2185 
    args.orderId = orderId
2186 
    args.write(self._oprot)
2187 
    self._oprot.writeMessageEnd()
2188 
    self._oprot.trans.flush()
2189 
 
2190 
  def recv_markOrderAsOutOfStock(self, ):
2191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2192 
    if mtype == TMessageType.EXCEPTION:
2193 
      x = TApplicationException()
2194 
      x.read(self._iprot)
2195 
      self._iprot.readMessageEnd()
2196 
      raise x
2197 
    result = markOrderAsOutOfStock_result()
2198 
    result.read(self._iprot)
2199 
    self._iprot.readMessageEnd()
3431 rajveer 2200 
    if result.success is not None:
1208 chandransh 2201 
      return result.success
3431 rajveer 2202 
    if result.ex is not None:
1208 chandransh 2203 
      raise result.ex
2204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2205 
 
3064 chandransh 2206 
  def verifyOrder(self, orderId):
759 chandransh 2207 
    """
3064 chandransh 2208 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2209 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2210 
    used for all other orders as well.
2211 
    Throws an exception if no such order exists.
3431 rajveer 2212 
 
759 chandransh 2213 
    Parameters:
3064 chandransh 2214 
     - orderId
759 chandransh 2215 
    """
3064 chandransh 2216 
    self.send_verifyOrder(orderId)
2217 
    return self.recv_verifyOrder()
759 chandransh 2218 
 
3064 chandransh 2219 
  def send_verifyOrder(self, orderId):
2220 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2221 
    args = verifyOrder_args()
2222 
    args.orderId = orderId
759 chandransh 2223 
    args.write(self._oprot)
2224 
    self._oprot.writeMessageEnd()
2225 
    self._oprot.trans.flush()
2226 
 
3064 chandransh 2227 
  def recv_verifyOrder(self, ):
759 chandransh 2228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2229 
    if mtype == TMessageType.EXCEPTION:
2230 
      x = TApplicationException()
2231 
      x.read(self._iprot)
2232 
      self._iprot.readMessageEnd()
2233 
      raise x
3064 chandransh 2234 
    result = verifyOrder_result()
759 chandransh 2235 
    result.read(self._iprot)
2236 
    self._iprot.readMessageEnd()
3431 rajveer 2237 
    if result.success is not None:
759 chandransh 2238 
      return result.success
3431 rajveer 2239 
    if result.ex is not None:
759 chandransh 2240 
      raise result.ex
3064 chandransh 2241 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2242 
 
3064 chandransh 2243 
  def acceptOrder(self, orderId):
1113 chandransh 2244 
    """
3064 chandransh 2245 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2246 
    given order is not a COD order, it also captures the payment if the same has
2247 
    not been captured.
2248 
    Throws an exception if no such order exists.
3431 rajveer 2249 
 
1113 chandransh 2250 
    Parameters:
3064 chandransh 2251 
     - orderId
1113 chandransh 2252 
    """
3064 chandransh 2253 
    self.send_acceptOrder(orderId)
2254 
    return self.recv_acceptOrder()
1113 chandransh 2255 
 
3064 chandransh 2256 
  def send_acceptOrder(self, orderId):
2257 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2258 
    args = acceptOrder_args()
2259 
    args.orderId = orderId
1113 chandransh 2260 
    args.write(self._oprot)
2261 
    self._oprot.writeMessageEnd()
2262 
    self._oprot.trans.flush()
2263 
 
3064 chandransh 2264 
  def recv_acceptOrder(self, ):
1113 chandransh 2265 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2266 
    if mtype == TMessageType.EXCEPTION:
2267 
      x = TApplicationException()
2268 
      x.read(self._iprot)
2269 
      self._iprot.readMessageEnd()
2270 
      raise x
3064 chandransh 2271 
    result = acceptOrder_result()
1113 chandransh 2272 
    result.read(self._iprot)
2273 
    self._iprot.readMessageEnd()
3431 rajveer 2274 
    if result.success is not None:
1113 chandransh 2275 
      return result.success
3431 rajveer 2276 
    if result.ex is not None:
1113 chandransh 2277 
      raise result.ex
3064 chandransh 2278 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2279 
 
5110 mandeep.dh 2280 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2281 
    """
3064 chandransh 2282 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2283 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2284 
    the IMEI no. if a -1 is supplied.
2285 
    Also, it generates an invoice number for the order, marks the order as
2286 
    BILLED and sets the billing timestamp.
2287 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2288 
 
1135 chandransh 2289 
    Parameters:
3064 chandransh 2290 
     - orderId
2291 
     - invoice_number
4658 mandeep.dh 2292 
     - serialNumber
4283 anupam.sin 2293 
     - itemNumber
3064 chandransh 2294 
     - billed_by
4264 rajveer 2295 
     - jacketNumber
4283 anupam.sin 2296 
     - billingType
5110 mandeep.dh 2297 
     - fulfilmentWarehouseId
4763 rajveer 2298 
     - authorize
1135 chandransh 2299 
    """
5110 mandeep.dh 2300 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2301 
    return self.recv_addBillingDetails()
1135 chandransh 2302 
 
5110 mandeep.dh 2303 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2304 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2305 
    args = addBillingDetails_args()
2306 
    args.orderId = orderId
2307 
    args.invoice_number = invoice_number
4658 mandeep.dh 2308 
    args.serialNumber = serialNumber
4283 anupam.sin 2309 
    args.itemNumber = itemNumber
3064 chandransh 2310 
    args.billed_by = billed_by
4264 rajveer 2311 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2312 
    args.billingType = billingType
5110 mandeep.dh 2313 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2314 
    args.authorize = authorize
1135 chandransh 2315 
    args.write(self._oprot)
2316 
    self._oprot.writeMessageEnd()
2317 
    self._oprot.trans.flush()
2318 
 
3064 chandransh 2319 
  def recv_addBillingDetails(self, ):
1135 chandransh 2320 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2321 
    if mtype == TMessageType.EXCEPTION:
2322 
      x = TApplicationException()
2323 
      x.read(self._iprot)
2324 
      self._iprot.readMessageEnd()
2325 
      raise x
3064 chandransh 2326 
    result = addBillingDetails_result()
1135 chandransh 2327 
    result.read(self._iprot)
2328 
    self._iprot.readMessageEnd()
3431 rajveer 2329 
    if result.success is not None:
3064 chandransh 2330 
      return result.success
3431 rajveer 2331 
    if result.ex is not None:
1135 chandransh 2332 
      raise result.ex
3064 chandransh 2333 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2334 
 
4763 rajveer 2335 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2336 
    """
2337 
    Add the invoice number to the order.
2338 
 
2339 
    Parameters:
2340 
     - orderId
2341 
     - invoiceNumber
4763 rajveer 2342 
     - color
4579 rajveer 2343 
    """
4763 rajveer 2344 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2345 
    self.recv_addInvoiceNumber()
2346 
 
4763 rajveer 2347 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2348 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2349 
    args = addInvoiceNumber_args()
2350 
    args.orderId = orderId
2351 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2352 
    args.color = color
4579 rajveer 2353 
    args.write(self._oprot)
2354 
    self._oprot.writeMessageEnd()
2355 
    self._oprot.trans.flush()
2356 
 
2357 
  def recv_addInvoiceNumber(self, ):
2358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2359 
    if mtype == TMessageType.EXCEPTION:
2360 
      x = TApplicationException()
2361 
      x.read(self._iprot)
2362 
      self._iprot.readMessageEnd()
2363 
      raise x
2364 
    result = addInvoiceNumber_result()
2365 
    result.read(self._iprot)
2366 
    self._iprot.readMessageEnd()
2367 
    if result.ex is not None:
2368 
      raise result.ex
2369 
    return
2370 
 
4910 phani.kuma 2371 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2372 
    """
3064 chandransh 2373 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2374 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2375 
 
1408 ankur.sing 2376 
    Parameters:
3064 chandransh 2377 
     - warehouseId
1408 ankur.sing 2378 
     - providerId
3064 chandransh 2379 
     - cod
4910 phani.kuma 2380 
     - orderIds
1408 ankur.sing 2381 
    """
4910 phani.kuma 2382 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2383 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2384 
 
4910 phani.kuma 2385 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2386 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2387 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2388 
    args.warehouseId = warehouseId
1408 ankur.sing 2389 
    args.providerId = providerId
3064 chandransh 2390 
    args.cod = cod
4910 phani.kuma 2391 
    args.orderIds = orderIds
1408 ankur.sing 2392 
    args.write(self._oprot)
2393 
    self._oprot.writeMessageEnd()
2394 
    self._oprot.trans.flush()
2395 
 
4910 phani.kuma 2396 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2398 
    if mtype == TMessageType.EXCEPTION:
2399 
      x = TApplicationException()
2400 
      x.read(self._iprot)
2401 
      self._iprot.readMessageEnd()
2402 
      raise x
4910 phani.kuma 2403 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2404 
    result.read(self._iprot)
2405 
    self._iprot.readMessageEnd()
3431 rajveer 2406 
    if result.success is not None:
1408 ankur.sing 2407 
      return result.success
3431 rajveer 2408 
    if result.ex is not None:
3064 chandransh 2409 
      raise result.ex
4910 phani.kuma 2410 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2411 
 
4910 phani.kuma 2412 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2413 
    """
4910 phani.kuma 2414 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2415 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2416 
 
2417 
    Parameters:
2418 
     - providerId
4910 phani.kuma 2419 
     - pickupDetails
4410 rajveer 2420 
    """
4910 phani.kuma 2421 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2422 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2423 
 
4910 phani.kuma 2424 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2425 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2426 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2427 
    args.providerId = providerId
4910 phani.kuma 2428 
    args.pickupDetails = pickupDetails
4410 rajveer 2429 
    args.write(self._oprot)
2430 
    self._oprot.writeMessageEnd()
2431 
    self._oprot.trans.flush()
2432 
 
4910 phani.kuma 2433 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2435 
    if mtype == TMessageType.EXCEPTION:
2436 
      x = TApplicationException()
2437 
      x.read(self._iprot)
2438 
      self._iprot.readMessageEnd()
2439 
      raise x
4910 phani.kuma 2440 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2441 
    result.read(self._iprot)
2442 
    self._iprot.readMessageEnd()
2443 
    if result.ex is not None:
2444 
      raise result.ex
4910 phani.kuma 2445 
    return
4410 rajveer 2446 
 
4910 phani.kuma 2447 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2448 
    """
3064 chandransh 2449 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2450 
 
94 ashish 2451 
    Parameters:
3064 chandransh 2452 
     - providerId
304 ashish 2453 
    """
4910 phani.kuma 2454 
    self.send_getOrdersNotPickedUp(providerId)
2455 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2456 
 
4910 phani.kuma 2457 
  def send_getOrdersNotPickedUp(self, providerId):
2458 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2459 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2460 
    args.providerId = providerId
304 ashish 2461 
    args.write(self._oprot)
2462 
    self._oprot.writeMessageEnd()
2463 
    self._oprot.trans.flush()
2464 
 
4910 phani.kuma 2465 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2467 
    if mtype == TMessageType.EXCEPTION:
2468 
      x = TApplicationException()
2469 
      x.read(self._iprot)
2470 
      self._iprot.readMessageEnd()
2471 
      raise x
4910 phani.kuma 2472 
    result = getOrdersNotPickedUp_result()
304 ashish 2473 
    result.read(self._iprot)
2474 
    self._iprot.readMessageEnd()
3431 rajveer 2475 
    if result.success is not None:
304 ashish 2476 
      return result.success
4910 phani.kuma 2477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2478 
 
3064 chandransh 2479 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2480 
    """
3064 chandransh 2481 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2482 
    the name of the receiver.
2483 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2484 
 
304 ashish 2485 
    Parameters:
3064 chandransh 2486 
     - providerId
2487 
     - deliveredOrders
304 ashish 2488 
    """
3064 chandransh 2489 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2490 
    self.recv_markOrdersAsDelivered()
304 ashish 2491 
 
3064 chandransh 2492 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2493 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2494 
    args = markOrdersAsDelivered_args()
2495 
    args.providerId = providerId
2496 
    args.deliveredOrders = deliveredOrders
304 ashish 2497 
    args.write(self._oprot)
2498 
    self._oprot.writeMessageEnd()
2499 
    self._oprot.trans.flush()
2500 
 
3064 chandransh 2501 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2503 
    if mtype == TMessageType.EXCEPTION:
2504 
      x = TApplicationException()
2505 
      x.read(self._iprot)
2506 
      self._iprot.readMessageEnd()
2507 
      raise x
3064 chandransh 2508 
    result = markOrdersAsDelivered_result()
304 ashish 2509 
    result.read(self._iprot)
2510 
    self._iprot.readMessageEnd()
3431 rajveer 2511 
    if result.ex is not None:
3064 chandransh 2512 
      raise result.ex
304 ashish 2513 
    return
2514 
 
4910 phani.kuma 2515 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2516 
    """
4910 phani.kuma 2517 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2518 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2519 
 
3064 chandransh 2520 
    Parameters:
2521 
     - providerId
2522 
     - returnedOrders
1596 ankur.sing 2523 
    """
4910 phani.kuma 2524 
    self.send_markAsRTOrders(providerId, returnedOrders)
2525 
    self.recv_markAsRTOrders()
304 ashish 2526 
 
4910 phani.kuma 2527 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2528 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2529 
    args = markAsRTOrders_args()
3064 chandransh 2530 
    args.providerId = providerId
2531 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2532 
    args.write(self._oprot)
2533 
    self._oprot.writeMessageEnd()
2534 
    self._oprot.trans.flush()
2535 
 
4910 phani.kuma 2536 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2537 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2538 
    if mtype == TMessageType.EXCEPTION:
2539 
      x = TApplicationException()
2540 
      x.read(self._iprot)
2541 
      self._iprot.readMessageEnd()
2542 
      raise x
4910 phani.kuma 2543 
    result = markAsRTOrders_result()
1596 ankur.sing 2544 
    result.read(self._iprot)
2545 
    self._iprot.readMessageEnd()
3431 rajveer 2546 
    if result.ex is not None:
3064 chandransh 2547 
      raise result.ex
2548 
    return
1596 ankur.sing 2549 
 
4910 phani.kuma 2550 
  def getRTOrders(self, providerId):
2551 
    """
2552 
    Returns a list of orders that were returned by courier.
2553 
 
2554 
    Parameters:
2555 
     - providerId
2556 
    """
2557 
    self.send_getRTOrders(providerId)
2558 
    return self.recv_getRTOrders()
2559 
 
2560 
  def send_getRTOrders(self, providerId):
2561 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2562 
    args = getRTOrders_args()
2563 
    args.providerId = providerId
2564 
    args.write(self._oprot)
2565 
    self._oprot.writeMessageEnd()
2566 
    self._oprot.trans.flush()
2567 
 
2568 
  def recv_getRTOrders(self, ):
2569 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2570 
    if mtype == TMessageType.EXCEPTION:
2571 
      x = TApplicationException()
2572 
      x.read(self._iprot)
2573 
      self._iprot.readMessageEnd()
2574 
      raise x
2575 
    result = getRTOrders_result()
2576 
    result.read(self._iprot)
2577 
    self._iprot.readMessageEnd()
2578 
    if result.success is not None:
2579 
      return result.success
2580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2581 
 
3064 chandransh 2582 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2583 
    """
3064 chandransh 2584 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2585 
 
3064 chandransh 2586 
    Parameters:
2587 
     - providerId
2588 
     - undeliveredOrders
1627 ankur.sing 2589 
    """
3064 chandransh 2590 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2591 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2592 
 
3064 chandransh 2593 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2594 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2595 
    args = updateNonDeliveryReason_args()
2596 
    args.providerId = providerId
2597 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2598 
    args.write(self._oprot)
2599 
    self._oprot.writeMessageEnd()
2600 
    self._oprot.trans.flush()
2601 
 
3064 chandransh 2602 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2604 
    if mtype == TMessageType.EXCEPTION:
2605 
      x = TApplicationException()
2606 
      x.read(self._iprot)
2607 
      self._iprot.readMessageEnd()
2608 
      raise x
3064 chandransh 2609 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2610 
    result.read(self._iprot)
2611 
    self._iprot.readMessageEnd()
4910 phani.kuma 2612 
    if result.ex is not None:
2613 
      raise result.ex
2614 
    return
2615 
 
2616 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2617 
    """
2618 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2619 
 
2620 
    Parameters:
2621 
     - providerId
2622 
    """
2623 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2624 
    return self.recv_getNonDeliveredOrdersbyCourier()
2625 
 
2626 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2627 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2628 
    args = getNonDeliveredOrdersbyCourier_args()
2629 
    args.providerId = providerId
2630 
    args.write(self._oprot)
2631 
    self._oprot.writeMessageEnd()
2632 
    self._oprot.trans.flush()
2633 
 
2634 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2636 
    if mtype == TMessageType.EXCEPTION:
2637 
      x = TApplicationException()
2638 
      x.read(self._iprot)
2639 
      self._iprot.readMessageEnd()
2640 
      raise x
2641 
    result = getNonDeliveredOrdersbyCourier_result()
2642 
    result.read(self._iprot)
2643 
    self._iprot.readMessageEnd()
4581 phani.kuma 2644 
    if result.success is not None:
2645 
      return result.success
4910 phani.kuma 2646 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2647 
 
2648 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2649 
    """
2650 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2651 
 
2652 
    Parameters:
2653 
     - providerId
2654 
     - local_connected_orders
2655 
    """
2656 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2657 
    self.recv_markOrdersAsLocalConnected()
2658 
 
2659 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2660 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2661 
    args = markOrdersAsLocalConnected_args()
2662 
    args.providerId = providerId
2663 
    args.local_connected_orders = local_connected_orders
2664 
    args.write(self._oprot)
2665 
    self._oprot.writeMessageEnd()
2666 
    self._oprot.trans.flush()
2667 
 
2668 
  def recv_markOrdersAsLocalConnected(self, ):
2669 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2670 
    if mtype == TMessageType.EXCEPTION:
2671 
      x = TApplicationException()
2672 
      x.read(self._iprot)
2673 
      self._iprot.readMessageEnd()
2674 
      raise x
2675 
    result = markOrdersAsLocalConnected_result()
2676 
    result.read(self._iprot)
2677 
    self._iprot.readMessageEnd()
3431 rajveer 2678 
    if result.ex is not None:
3064 chandransh 2679 
      raise result.ex
4910 phani.kuma 2680 
    return
1627 ankur.sing 2681 
 
4910 phani.kuma 2682 
  def getOrdersNotLocalConnected(self, providerId):
2683 
    """
2684 
    Returns a list of orders that were picked up or shipped but pending local connection.
2685 
 
2686 
    Parameters:
2687 
     - providerId
2688 
    """
2689 
    self.send_getOrdersNotLocalConnected(providerId)
2690 
    return self.recv_getOrdersNotLocalConnected()
2691 
 
2692 
  def send_getOrdersNotLocalConnected(self, providerId):
2693 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2694 
    args = getOrdersNotLocalConnected_args()
2695 
    args.providerId = providerId
2696 
    args.write(self._oprot)
2697 
    self._oprot.writeMessageEnd()
2698 
    self._oprot.trans.flush()
2699 
 
2700 
  def recv_getOrdersNotLocalConnected(self, ):
2701 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2702 
    if mtype == TMessageType.EXCEPTION:
2703 
      x = TApplicationException()
2704 
      x.read(self._iprot)
2705 
      self._iprot.readMessageEnd()
2706 
      raise x
2707 
    result = getOrdersNotLocalConnected_result()
2708 
    result.read(self._iprot)
2709 
    self._iprot.readMessageEnd()
2710 
    if result.success is not None:
2711 
      return result.success
2712 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2713 
 
2714 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2715 
    """
2716 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2717 
 
2718 
    Parameters:
2719 
     - providerId
2720 
     - destination_city_reached_orders
2721 
    """
2722 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2723 
    self.recv_markOrdersAsDestinationCityReached()
2724 
 
2725 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2726 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2727 
    args = markOrdersAsDestinationCityReached_args()
2728 
    args.providerId = providerId
2729 
    args.destination_city_reached_orders = destination_city_reached_orders
2730 
    args.write(self._oprot)
2731 
    self._oprot.writeMessageEnd()
2732 
    self._oprot.trans.flush()
2733 
 
2734 
  def recv_markOrdersAsDestinationCityReached(self, ):
2735 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2736 
    if mtype == TMessageType.EXCEPTION:
2737 
      x = TApplicationException()
2738 
      x.read(self._iprot)
2739 
      self._iprot.readMessageEnd()
2740 
      raise x
2741 
    result = markOrdersAsDestinationCityReached_result()
2742 
    result.read(self._iprot)
2743 
    self._iprot.readMessageEnd()
2744 
    if result.ex is not None:
2745 
      raise result.ex
2746 
    return
2747 
 
2748 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2749 
    """
2750 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
2751 
 
2752 
    Parameters:
2753 
     - providerId
2754 
     - first_atdl_orders
2755 
    """
2756 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
2757 
    self.recv_markOrdersAsFirstDeliveryAttempted()
2758 
 
2759 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2760 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
2761 
    args = markOrdersAsFirstDeliveryAttempted_args()
2762 
    args.providerId = providerId
2763 
    args.first_atdl_orders = first_atdl_orders
2764 
    args.write(self._oprot)
2765 
    self._oprot.writeMessageEnd()
2766 
    self._oprot.trans.flush()
2767 
 
2768 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
2769 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2770 
    if mtype == TMessageType.EXCEPTION:
2771 
      x = TApplicationException()
2772 
      x.read(self._iprot)
2773 
      self._iprot.readMessageEnd()
2774 
      raise x
2775 
    result = markOrdersAsFirstDeliveryAttempted_result()
2776 
    result.read(self._iprot)
2777 
    self._iprot.readMessageEnd()
2778 
    if result.ex is not None:
2779 
      raise result.ex
2780 
    return
2781 
 
3064 chandransh 2782 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2783 
    """
3064 chandransh 2784 
    Returns the list of orders whose delivery time has passed but have not been
2785 
    delivered yet for the given provider and warehouse. To get a complete list of
2786 
    undelivered orders, pass them as -1.
2787 
    Returns an empty list if no such orders exist.
3431 rajveer 2788 
 
1886 ankur.sing 2789 
    Parameters:
3064 chandransh 2790 
     - providerId
2791 
     - warehouseId
1886 ankur.sing 2792 
    """
3064 chandransh 2793 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2794 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2795 
 
3064 chandransh 2796 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
2797 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
2798 
    args = getUndeliveredOrders_args()
2799 
    args.providerId = providerId
2800 
    args.warehouseId = warehouseId
1886 ankur.sing 2801 
    args.write(self._oprot)
2802 
    self._oprot.writeMessageEnd()
2803 
    self._oprot.trans.flush()
2804 
 
3064 chandransh 2805 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 2806 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2807 
    if mtype == TMessageType.EXCEPTION:
2808 
      x = TApplicationException()
2809 
      x.read(self._iprot)
2810 
      self._iprot.readMessageEnd()
2811 
      raise x
3064 chandransh 2812 
    result = getUndeliveredOrders_result()
1886 ankur.sing 2813 
    result.read(self._iprot)
2814 
    self._iprot.readMessageEnd()
3431 rajveer 2815 
    if result.success is not None:
1886 ankur.sing 2816 
      return result.success
3064 chandransh 2817 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 2818 
 
4783 phani.kuma 2819 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2820 
    """
2821 
    Returns the list of orders whose expected delivery date has passed but have not been
2822 
    delivered yet.
2823 
    Returns an empty list if no such orders exist.
2824 
    """
2825 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2826 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
2827 
 
2828 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2829 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
2830 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
2831 
    args.write(self._oprot)
2832 
    self._oprot.writeMessageEnd()
2833 
    self._oprot.trans.flush()
2834 
 
2835 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
2836 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2837 
    if mtype == TMessageType.EXCEPTION:
2838 
      x = TApplicationException()
2839 
      x.read(self._iprot)
2840 
      self._iprot.readMessageEnd()
2841 
      raise x
2842 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
2843 
    result.read(self._iprot)
2844 
    self._iprot.readMessageEnd()
2845 
    if result.success is not None:
2846 
      return result.success
2847 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
2848 
 
2536 chandransh 2849 
  def toggleDOAFlag(self, orderId):
2850 
    """
2851 
    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.
2852 
    Returns the final flag status.
2853 
    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 2854 
 
2536 chandransh 2855 
    Parameters:
2856 
     - orderId
2857 
    """
2858 
    self.send_toggleDOAFlag(orderId)
2859 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 2860 
 
2536 chandransh 2861 
  def send_toggleDOAFlag(self, orderId):
2862 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
2863 
    args = toggleDOAFlag_args()
2864 
    args.orderId = orderId
2865 
    args.write(self._oprot)
2866 
    self._oprot.writeMessageEnd()
2867 
    self._oprot.trans.flush()
2868 
 
2869 
  def recv_toggleDOAFlag(self, ):
2870 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2871 
    if mtype == TMessageType.EXCEPTION:
2872 
      x = TApplicationException()
2873 
      x.read(self._iprot)
2874 
      self._iprot.readMessageEnd()
2875 
      raise x
2876 
    result = toggleDOAFlag_result()
2877 
    result.read(self._iprot)
2878 
    self._iprot.readMessageEnd()
3431 rajveer 2879 
    if result.success is not None:
2536 chandransh 2880 
      return result.success
3431 rajveer 2881 
    if result.ex is not None:
2536 chandransh 2882 
      raise result.ex
2883 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
2884 
 
4712 rajveer 2885 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2886 
    """
2887 
    Parameters:
2888 
     - orderId
2889 
     - deliveryTimestamp
2890 
     - receiver
2891 
    """
2892 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
2893 
    self.recv_markOrderAsDelivered()
2894 
 
2895 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
2896 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
2897 
    args = markOrderAsDelivered_args()
2898 
    args.orderId = orderId
2899 
    args.deliveryTimestamp = deliveryTimestamp
2900 
    args.receiver = receiver
2901 
    args.write(self._oprot)
2902 
    self._oprot.writeMessageEnd()
2903 
    self._oprot.trans.flush()
2904 
 
2905 
  def recv_markOrderAsDelivered(self, ):
2906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2907 
    if mtype == TMessageType.EXCEPTION:
2908 
      x = TApplicationException()
2909 
      x.read(self._iprot)
2910 
      self._iprot.readMessageEnd()
2911 
      raise x
2912 
    result = markOrderAsDelivered_result()
2913 
    result.read(self._iprot)
2914 
    self._iprot.readMessageEnd()
2915 
    if result.ex is not None:
2916 
      raise result.ex
2917 
    return
2918 
 
4454 rajveer 2919 
  def markOrderDoaRequestReceived(self, orderId):
2920 
    """
2921 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
2922 
 
2923 
    Parameters:
2924 
     - orderId
2925 
    """
2926 
    self.send_markOrderDoaRequestReceived(orderId)
2927 
    return self.recv_markOrderDoaRequestReceived()
2928 
 
2929 
  def send_markOrderDoaRequestReceived(self, orderId):
2930 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
2931 
    args = markOrderDoaRequestReceived_args()
2932 
    args.orderId = orderId
2933 
    args.write(self._oprot)
2934 
    self._oprot.writeMessageEnd()
2935 
    self._oprot.trans.flush()
2936 
 
2937 
  def recv_markOrderDoaRequestReceived(self, ):
2938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2939 
    if mtype == TMessageType.EXCEPTION:
2940 
      x = TApplicationException()
2941 
      x.read(self._iprot)
2942 
      self._iprot.readMessageEnd()
2943 
      raise x
2944 
    result = markOrderDoaRequestReceived_result()
2945 
    result.read(self._iprot)
2946 
    self._iprot.readMessageEnd()
2947 
    if result.success is not None:
2948 
      return result.success
2949 
    if result.ex is not None:
2950 
      raise result.ex
2951 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
2952 
 
2953 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2954 
    """
2955 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
2956 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
2957 
 
2958 
    Parameters:
2959 
     - orderId
2960 
     - isAuthorized
2961 
    """
2962 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
2963 
    return self.recv_markOrderDoaRequestAuthorized()
2964 
 
2965 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
2966 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
2967 
    args = markOrderDoaRequestAuthorized_args()
2968 
    args.orderId = orderId
2969 
    args.isAuthorized = isAuthorized
2970 
    args.write(self._oprot)
2971 
    self._oprot.writeMessageEnd()
2972 
    self._oprot.trans.flush()
2973 
 
2974 
  def recv_markOrderDoaRequestAuthorized(self, ):
2975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2976 
    if mtype == TMessageType.EXCEPTION:
2977 
      x = TApplicationException()
2978 
      x.read(self._iprot)
2979 
      self._iprot.readMessageEnd()
2980 
      raise x
2981 
    result = markOrderDoaRequestAuthorized_result()
2982 
    result.read(self._iprot)
2983 
    self._iprot.readMessageEnd()
2984 
    if result.success is not None:
2985 
      return result.success
2986 
    if result.ex is not None:
2987 
      raise result.ex
2988 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
2989 
 
4488 rajveer 2990 
  def markOrderReturnRequestReceived(self, orderId):
2991 
    """
2992 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
2993 
 
2994 
    Parameters:
2995 
     - orderId
2996 
    """
2997 
    self.send_markOrderReturnRequestReceived(orderId)
2998 
    return self.recv_markOrderReturnRequestReceived()
2999 
 
3000 
  def send_markOrderReturnRequestReceived(self, orderId):
3001 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3002 
    args = markOrderReturnRequestReceived_args()
3003 
    args.orderId = orderId
3004 
    args.write(self._oprot)
3005 
    self._oprot.writeMessageEnd()
3006 
    self._oprot.trans.flush()
3007 
 
3008 
  def recv_markOrderReturnRequestReceived(self, ):
3009 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3010 
    if mtype == TMessageType.EXCEPTION:
3011 
      x = TApplicationException()
3012 
      x.read(self._iprot)
3013 
      self._iprot.readMessageEnd()
3014 
      raise x
3015 
    result = markOrderReturnRequestReceived_result()
3016 
    result.read(self._iprot)
3017 
    self._iprot.readMessageEnd()
3018 
    if result.success is not None:
3019 
      return result.success
3020 
    if result.ex is not None:
3021 
      raise result.ex
3022 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3023 
 
3024 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3025 
    """
3026 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3027 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3028 
 
3029 
    Parameters:
3030 
     - orderId
3031 
     - isAuthorized
3032 
    """
3033 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3034 
    return self.recv_markOrderReturnRequestAuthorized()
3035 
 
3036 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3037 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3038 
    args = markOrderReturnRequestAuthorized_args()
3039 
    args.orderId = orderId
3040 
    args.isAuthorized = isAuthorized
3041 
    args.write(self._oprot)
3042 
    self._oprot.writeMessageEnd()
3043 
    self._oprot.trans.flush()
3044 
 
3045 
  def recv_markOrderReturnRequestAuthorized(self, ):
3046 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3047 
    if mtype == TMessageType.EXCEPTION:
3048 
      x = TApplicationException()
3049 
      x.read(self._iprot)
3050 
      self._iprot.readMessageEnd()
3051 
      raise x
3052 
    result = markOrderReturnRequestAuthorized_result()
3053 
    result.read(self._iprot)
3054 
    self._iprot.readMessageEnd()
3055 
    if result.success is not None:
3056 
      return result.success
3057 
    if result.ex is not None:
3058 
      raise result.ex
3059 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3060 
 
4579 rajveer 3061 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3062 
    """
3063 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3064 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3065 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3066 
    For any other status, it returns false.
3067 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3068 
 
2536 chandransh 3069 
    Parameters:
3070 
     - orderId
4579 rajveer 3071 
     - providerId
2536 chandransh 3072 
    """
4579 rajveer 3073 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3074 
    return self.recv_requestPickupNumber()
3075 
 
4579 rajveer 3076 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3077 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3078 
    args = requestPickupNumber_args()
3079 
    args.orderId = orderId
4579 rajveer 3080 
    args.providerId = providerId
2536 chandransh 3081 
    args.write(self._oprot)
3082 
    self._oprot.writeMessageEnd()
3083 
    self._oprot.trans.flush()
3084 
 
3085 
  def recv_requestPickupNumber(self, ):
3086 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3087 
    if mtype == TMessageType.EXCEPTION:
3088 
      x = TApplicationException()
3089 
      x.read(self._iprot)
3090 
      self._iprot.readMessageEnd()
3091 
      raise x
3092 
    result = requestPickupNumber_result()
3093 
    result.read(self._iprot)
3094 
    self._iprot.readMessageEnd()
3431 rajveer 3095 
    if result.success is not None:
2536 chandransh 3096 
      return result.success
3431 rajveer 3097 
    if result.ex is not None:
2536 chandransh 3098 
      raise result.ex
3099 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3100 
 
4602 rajveer 3101 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3102 
    """
4452 rajveer 3103 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3104 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3105 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3106 
    	3. Returns true
2591 chandransh 3107 
    If the order is in any other status, it returns false.
2536 chandransh 3108 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3109 
 
2536 chandransh 3110 
    Parameters:
3111 
     - orderId
3112 
     - pickupNumber
4602 rajveer 3113 
     - providerId
2536 chandransh 3114 
    """
4602 rajveer 3115 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3116 
    return self.recv_authorizePickup()
3117 
 
4602 rajveer 3118 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3119 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3120 
    args = authorizePickup_args()
3121 
    args.orderId = orderId
3122 
    args.pickupNumber = pickupNumber
4602 rajveer 3123 
    args.providerId = providerId
2536 chandransh 3124 
    args.write(self._oprot)
3125 
    self._oprot.writeMessageEnd()
3126 
    self._oprot.trans.flush()
3127 
 
3128 
  def recv_authorizePickup(self, ):
3129 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3130 
    if mtype == TMessageType.EXCEPTION:
3131 
      x = TApplicationException()
3132 
      x.read(self._iprot)
3133 
      self._iprot.readMessageEnd()
3134 
      raise x
3135 
    result = authorizePickup_result()
3136 
    result.read(self._iprot)
3137 
    self._iprot.readMessageEnd()
3431 rajveer 3138 
    if result.success is not None:
2536 chandransh 3139 
      return result.success
3431 rajveer 3140 
    if result.ex is not None:
2536 chandransh 3141 
      raise result.ex
3142 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3143 
 
2764 chandransh 3144 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3145 
    """
3146 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3147 
 
2764 chandransh 3148 
    Parameters:
3149 
     - providerId
3150 
     - pickupDetails
3151 
    """
3152 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3153 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3154 
 
3155 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3156 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3157 
    args = markDoasAsPickedUp_args()
3158 
    args.providerId = providerId
3159 
    args.pickupDetails = pickupDetails
3160 
    args.write(self._oprot)
3161 
    self._oprot.writeMessageEnd()
3162 
    self._oprot.trans.flush()
3163 
 
3164 
  def recv_markDoasAsPickedUp(self, ):
3165 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3166 
    if mtype == TMessageType.EXCEPTION:
3167 
      x = TApplicationException()
3168 
      x.read(self._iprot)
3169 
      self._iprot.readMessageEnd()
3170 
      raise x
3171 
    result = markDoasAsPickedUp_result()
3172 
    result.read(self._iprot)
3173 
    self._iprot.readMessageEnd()
4910 phani.kuma 3174 
    return
3175 
 
3176 
  def getDoasNotPickedUp(self, providerId):
3177 
    """
3178 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3179 
 
3180 
    Parameters:
3181 
     - providerId
3182 
    """
3183 
    self.send_getDoasNotPickedUp(providerId)
3184 
    return self.recv_getDoasNotPickedUp()
3185 
 
3186 
  def send_getDoasNotPickedUp(self, providerId):
3187 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3188 
    args = getDoasNotPickedUp_args()
3189 
    args.providerId = providerId
3190 
    args.write(self._oprot)
3191 
    self._oprot.writeMessageEnd()
3192 
    self._oprot.trans.flush()
3193 
 
3194 
  def recv_getDoasNotPickedUp(self, ):
3195 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3196 
    if mtype == TMessageType.EXCEPTION:
3197 
      x = TApplicationException()
3198 
      x.read(self._iprot)
3199 
      self._iprot.readMessageEnd()
3200 
      raise x
3201 
    result = getDoasNotPickedUp_result()
3202 
    result.read(self._iprot)
3203 
    self._iprot.readMessageEnd()
3431 rajveer 3204 
    if result.success is not None:
2764 chandransh 3205 
      return result.success
4910 phani.kuma 3206 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3207 
 
4741 phani.kuma 3208 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3209 
    """
3210 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3211 
 
3212 
    Parameters:
3213 
     - providerId
3214 
     - pickupDetails
3215 
    """
3216 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3217 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3218 
 
3219 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3220 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3221 
    args = markReturnOrdersAsPickedUp_args()
3222 
    args.providerId = providerId
3223 
    args.pickupDetails = pickupDetails
3224 
    args.write(self._oprot)
3225 
    self._oprot.writeMessageEnd()
3226 
    self._oprot.trans.flush()
3227 
 
3228 
  def recv_markReturnOrdersAsPickedUp(self, ):
3229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3230 
    if mtype == TMessageType.EXCEPTION:
3231 
      x = TApplicationException()
3232 
      x.read(self._iprot)
3233 
      self._iprot.readMessageEnd()
3234 
      raise x
3235 
    result = markReturnOrdersAsPickedUp_result()
3236 
    result.read(self._iprot)
3237 
    self._iprot.readMessageEnd()
4910 phani.kuma 3238 
    return
3239 
 
3240 
  def getReturnOrdersNotPickedUp(self, providerId):
3241 
    """
3242 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3243 
 
3244 
    Parameters:
3245 
     - providerId
3246 
    """
3247 
    self.send_getReturnOrdersNotPickedUp(providerId)
3248 
    return self.recv_getReturnOrdersNotPickedUp()
3249 
 
3250 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3251 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3252 
    args = getReturnOrdersNotPickedUp_args()
3253 
    args.providerId = providerId
3254 
    args.write(self._oprot)
3255 
    self._oprot.writeMessageEnd()
3256 
    self._oprot.trans.flush()
3257 
 
3258 
  def recv_getReturnOrdersNotPickedUp(self, ):
3259 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3260 
    if mtype == TMessageType.EXCEPTION:
3261 
      x = TApplicationException()
3262 
      x.read(self._iprot)
3263 
      self._iprot.readMessageEnd()
3264 
      raise x
3265 
    result = getReturnOrdersNotPickedUp_result()
3266 
    result.read(self._iprot)
3267 
    self._iprot.readMessageEnd()
4741 phani.kuma 3268 
    if result.success is not None:
3269 
      return result.success
4910 phani.kuma 3270 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3271 
 
4479 rajveer 3272 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3273 
    """
4452 rajveer 3274 
    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 3275 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3276 
    If the order is in any other state, it returns false.
3277 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3278 
 
2591 chandransh 3279 
    Parameters:
3280 
     - orderId
4479 rajveer 3281 
     - receiveCondition
2591 chandransh 3282 
    """
4479 rajveer 3283 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3284 
    return self.recv_receiveReturn()
2536 chandransh 3285 
 
4479 rajveer 3286 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3287 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3288 
    args = receiveReturn_args()
2591 chandransh 3289 
    args.orderId = orderId
4479 rajveer 3290 
    args.receiveCondition = receiveCondition
2591 chandransh 3291 
    args.write(self._oprot)
3292 
    self._oprot.writeMessageEnd()
3293 
    self._oprot.trans.flush()
3294 
 
2616 chandransh 3295 
  def recv_receiveReturn(self, ):
2591 chandransh 3296 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3297 
    if mtype == TMessageType.EXCEPTION:
3298 
      x = TApplicationException()
3299 
      x.read(self._iprot)
3300 
      self._iprot.readMessageEnd()
3301 
      raise x
2616 chandransh 3302 
    result = receiveReturn_result()
2591 chandransh 3303 
    result.read(self._iprot)
3304 
    self._iprot.readMessageEnd()
3431 rajveer 3305 
    if result.success is not None:
2591 chandransh 3306 
      return result.success
3431 rajveer 3307 
    if result.ex is not None:
2591 chandransh 3308 
      raise result.ex
2616 chandransh 3309 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3310 
 
3311 
  def validateDoa(self, orderId, isValid):
3312 
    """
4452 rajveer 3313 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3314 
    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 3315 
    If the order is in any other state, it returns false.
3316 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3317 
 
2591 chandransh 3318 
    Parameters:
3319 
     - orderId
3320 
     - isValid
3321 
    """
3322 
    self.send_validateDoa(orderId, isValid)
3323 
    return self.recv_validateDoa()
3324 
 
3325 
  def send_validateDoa(self, orderId, isValid):
3326 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3327 
    args = validateDoa_args()
3328 
    args.orderId = orderId
3329 
    args.isValid = isValid
3330 
    args.write(self._oprot)
3331 
    self._oprot.writeMessageEnd()
3332 
    self._oprot.trans.flush()
3333 
 
3334 
  def recv_validateDoa(self, ):
3335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3336 
    if mtype == TMessageType.EXCEPTION:
3337 
      x = TApplicationException()
3338 
      x.read(self._iprot)
3339 
      self._iprot.readMessageEnd()
3340 
      raise x
3341 
    result = validateDoa_result()
3342 
    result.read(self._iprot)
3343 
    self._iprot.readMessageEnd()
3431 rajveer 3344 
    if result.success is not None:
2591 chandransh 3345 
      return result.success
3431 rajveer 3346 
    if result.ex is not None:
2591 chandransh 3347 
      raise result.ex
3348 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3349 
 
4495 rajveer 3350 
  def validateReturnProduct(self, orderId, isUsable):
3351 
    """
3352 
    Parameters:
3353 
     - orderId
3354 
     - isUsable
3355 
    """
3356 
    self.send_validateReturnProduct(orderId, isUsable)
3357 
    return self.recv_validateReturnProduct()
3358 
 
3359 
  def send_validateReturnProduct(self, orderId, isUsable):
3360 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3361 
    args = validateReturnProduct_args()
3362 
    args.orderId = orderId
3363 
    args.isUsable = isUsable
3364 
    args.write(self._oprot)
3365 
    self._oprot.writeMessageEnd()
3366 
    self._oprot.trans.flush()
3367 
 
3368 
  def recv_validateReturnProduct(self, ):
3369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3370 
    if mtype == TMessageType.EXCEPTION:
3371 
      x = TApplicationException()
3372 
      x.read(self._iprot)
3373 
      self._iprot.readMessageEnd()
3374 
      raise x
3375 
    result = validateReturnProduct_result()
3376 
    result.read(self._iprot)
3377 
    self._iprot.readMessageEnd()
3378 
    if result.success is not None:
3379 
      return result.success
3380 
    if result.ex is not None:
3381 
      raise result.ex
3382 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3383 
 
2616 chandransh 3384 
  def reshipOrder(self, orderId):
3385 
    """
4484 rajveer 3386 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3387 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3388 
    	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 3389 
 
3390 
    If the order is in DOA_CERT_VALID state, it does the following:
3391 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3392 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3393 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3394 
 
2616 chandransh 3395 
    Returns the id of the newly created order.
3431 rajveer 3396 
 
2616 chandransh 3397 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3398 
 
2616 chandransh 3399 
    Parameters:
3400 
     - orderId
3401 
    """
3402 
    self.send_reshipOrder(orderId)
3403 
    return self.recv_reshipOrder()
2591 chandransh 3404 
 
2616 chandransh 3405 
  def send_reshipOrder(self, orderId):
3406 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3407 
    args = reshipOrder_args()
3408 
    args.orderId = orderId
3409 
    args.write(self._oprot)
3410 
    self._oprot.writeMessageEnd()
3411 
    self._oprot.trans.flush()
3412 
 
3413 
  def recv_reshipOrder(self, ):
3414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3415 
    if mtype == TMessageType.EXCEPTION:
3416 
      x = TApplicationException()
3417 
      x.read(self._iprot)
3418 
      self._iprot.readMessageEnd()
3419 
      raise x
3420 
    result = reshipOrder_result()
3421 
    result.read(self._iprot)
3422 
    self._iprot.readMessageEnd()
3431 rajveer 3423 
    if result.success is not None:
2616 chandransh 3424 
      return result.success
3431 rajveer 3425 
    if result.ex is not None:
2616 chandransh 3426 
      raise result.ex
3427 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3428 
 
3226 chandransh 3429 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3430 
    """
4484 rajveer 3431 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3432 
    	1. Creates a refund request for batch processing.
3433 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3434 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3435 
 
2616 chandransh 3436 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3437 
    	1. Creates a refund request for batch processing.
3226 chandransh 3438 
    	2. Cancels the reservation of the item in the warehouse.
3439 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3440 
 
3226 chandransh 3441 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3442 
    	1. Cancels the reservation of the item in the warehouse.
3443 
    	2. Marks the current order as CANCELED.
3444 
 
3445 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3446 
 
2616 chandransh 3447 
    Returns True if it is successful, False otherwise.
3431 rajveer 3448 
 
2616 chandransh 3449 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3450 
 
2616 chandransh 3451 
    Parameters:
3452 
     - orderId
3226 chandransh 3453 
     - refundedBy
3454 
     - reason
2616 chandransh 3455 
    """
3226 chandransh 3456 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3457 
    return self.recv_refundOrder()
3458 
 
3226 chandransh 3459 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3460 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3461 
    args = refundOrder_args()
3462 
    args.orderId = orderId
3226 chandransh 3463 
    args.refundedBy = refundedBy
3464 
    args.reason = reason
2616 chandransh 3465 
    args.write(self._oprot)
3466 
    self._oprot.writeMessageEnd()
3467 
    self._oprot.trans.flush()
3468 
 
3469 
  def recv_refundOrder(self, ):
3470 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3471 
    if mtype == TMessageType.EXCEPTION:
3472 
      x = TApplicationException()
3473 
      x.read(self._iprot)
3474 
      self._iprot.readMessageEnd()
3475 
      raise x
3476 
    result = refundOrder_result()
3477 
    result.read(self._iprot)
3478 
    self._iprot.readMessageEnd()
3431 rajveer 3479 
    if result.success is not None:
2616 chandransh 3480 
      return result.success
3431 rajveer 3481 
    if result.ex is not None:
2616 chandransh 3482 
      raise result.ex
3483 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3484 
 
2690 chandransh 3485 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3486 
    """
3487 
    Get all return orders created between the from and to dates for the given warehouse.
3488 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3489 
 
2690 chandransh 3490 
    Parameters:
3491 
     - warehouseId
3492 
     - fromDate
3493 
     - toDate
3494 
    """
3495 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3496 
    return self.recv_getReturnOrders()
2616 chandransh 3497 
 
2690 chandransh 3498 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3499 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3500 
    args = getReturnOrders_args()
3501 
    args.warehouseId = warehouseId
3502 
    args.fromDate = fromDate
3503 
    args.toDate = toDate
3504 
    args.write(self._oprot)
3505 
    self._oprot.writeMessageEnd()
3506 
    self._oprot.trans.flush()
3507 
 
3508 
  def recv_getReturnOrders(self, ):
3509 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3510 
    if mtype == TMessageType.EXCEPTION:
3511 
      x = TApplicationException()
3512 
      x.read(self._iprot)
3513 
      self._iprot.readMessageEnd()
3514 
      raise x
3515 
    result = getReturnOrders_result()
3516 
    result.read(self._iprot)
3517 
    self._iprot.readMessageEnd()
3431 rajveer 3518 
    if result.success is not None:
2690 chandransh 3519 
      return result.success
3520 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3521 
 
2700 chandransh 3522 
  def getReturnOrder(self, id):
3523 
    """
3524 
    Returns the ReturnOrder corresponding to the given id.
3525 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3526 
 
2700 chandransh 3527 
    Parameters:
3528 
     - id
3529 
    """
3530 
    self.send_getReturnOrder(id)
3531 
    return self.recv_getReturnOrder()
3532 
 
3533 
  def send_getReturnOrder(self, id):
3534 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3535 
    args = getReturnOrder_args()
3536 
    args.id = id
3537 
    args.write(self._oprot)
3538 
    self._oprot.writeMessageEnd()
3539 
    self._oprot.trans.flush()
3540 
 
3541 
  def recv_getReturnOrder(self, ):
3542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3543 
    if mtype == TMessageType.EXCEPTION:
3544 
      x = TApplicationException()
3545 
      x.read(self._iprot)
3546 
      self._iprot.readMessageEnd()
3547 
      raise x
3548 
    result = getReturnOrder_result()
3549 
    result.read(self._iprot)
3550 
    self._iprot.readMessageEnd()
3431 rajveer 3551 
    if result.success is not None:
2700 chandransh 3552 
      return result.success
3431 rajveer 3553 
    if result.ex is not None:
2700 chandransh 3554 
      raise result.ex
3555 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3556 
 
2690 chandransh 3557 
  def processReturn(self, returnOrderId):
3558 
    """
3559 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3560 
 
2690 chandransh 3561 
    Parameters:
3562 
     - returnOrderId
3563 
    """
3564 
    self.send_processReturn(returnOrderId)
3565 
    self.recv_processReturn()
3566 
 
3567 
  def send_processReturn(self, returnOrderId):
3568 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3569 
    args = processReturn_args()
3570 
    args.returnOrderId = returnOrderId
3571 
    args.write(self._oprot)
3572 
    self._oprot.writeMessageEnd()
3573 
    self._oprot.trans.flush()
3574 
 
3575 
  def recv_processReturn(self, ):
3576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3577 
    if mtype == TMessageType.EXCEPTION:
3578 
      x = TApplicationException()
3579 
      x.read(self._iprot)
3580 
      self._iprot.readMessageEnd()
3581 
      raise x
3582 
    result = processReturn_result()
3583 
    result.read(self._iprot)
3584 
    self._iprot.readMessageEnd()
3431 rajveer 3585 
    if result.ex is not None:
2690 chandransh 3586 
      raise result.ex
3587 
    return
3588 
 
3451 chandransh 3589 
  def updateWeight(self, orderId, weight):
3590 
    """
3591 
    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 3592 
 
3451 chandransh 3593 
    Parameters:
3594 
     - orderId
3595 
     - weight
3596 
    """
3597 
    self.send_updateWeight(orderId, weight)
3598 
    return self.recv_updateWeight()
3599 
 
3600 
  def send_updateWeight(self, orderId, weight):
3601 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3602 
    args = updateWeight_args()
3603 
    args.orderId = orderId
3604 
    args.weight = weight
3605 
    args.write(self._oprot)
3606 
    self._oprot.writeMessageEnd()
3607 
    self._oprot.trans.flush()
3608 
 
3609 
  def recv_updateWeight(self, ):
3610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3611 
    if mtype == TMessageType.EXCEPTION:
3612 
      x = TApplicationException()
3613 
      x.read(self._iprot)
3614 
      self._iprot.readMessageEnd()
3615 
      raise x
3616 
    result = updateWeight_result()
3617 
    result.read(self._iprot)
3618 
    self._iprot.readMessageEnd()
3619 
    if result.success is not None:
3620 
      return result.success
3621 
    if result.ex is not None:
3622 
      raise result.ex
3623 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3624 
 
3469 chandransh 3625 
  def changeItem(self, orderId, itemId):
3626 
    """
3627 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3628 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3629 
 
3469 chandransh 3630 
    Parameters:
3631 
     - orderId
3632 
     - itemId
3633 
    """
3634 
    self.send_changeItem(orderId, itemId)
3635 
    return self.recv_changeItem()
3636 
 
3637 
  def send_changeItem(self, orderId, itemId):
3638 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3639 
    args = changeItem_args()
3640 
    args.orderId = orderId
3641 
    args.itemId = itemId
3642 
    args.write(self._oprot)
3643 
    self._oprot.writeMessageEnd()
3644 
    self._oprot.trans.flush()
3645 
 
3646 
  def recv_changeItem(self, ):
3647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3648 
    if mtype == TMessageType.EXCEPTION:
3649 
      x = TApplicationException()
3650 
      x.read(self._iprot)
3651 
      self._iprot.readMessageEnd()
3652 
      raise x
3653 
    result = changeItem_result()
3654 
    result.read(self._iprot)
3655 
    self._iprot.readMessageEnd()
3656 
    if result.success is not None:
3657 
      return result.success
3658 
    if result.ex is not None:
3659 
      raise result.ex
3660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3661 
 
3662 
  def shiftToWarehouse(self, orderId, warehouseId):
3663 
    """
3664 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3665 
 
3666 
    Parameters:
3667 
     - orderId
3668 
     - warehouseId
3669 
    """
3670 
    self.send_shiftToWarehouse(orderId, warehouseId)
3671 
    return self.recv_shiftToWarehouse()
3672 
 
3673 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3674 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3675 
    args = shiftToWarehouse_args()
3676 
    args.orderId = orderId
3677 
    args.warehouseId = warehouseId
3678 
    args.write(self._oprot)
3679 
    self._oprot.writeMessageEnd()
3680 
    self._oprot.trans.flush()
3681 
 
3682 
  def recv_shiftToWarehouse(self, ):
3683 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3684 
    if mtype == TMessageType.EXCEPTION:
3685 
      x = TApplicationException()
3686 
      x.read(self._iprot)
3687 
      self._iprot.readMessageEnd()
3688 
      raise x
3689 
    result = shiftToWarehouse_result()
3690 
    result.read(self._iprot)
3691 
    self._iprot.readMessageEnd()
3692 
    if result.success is not None:
3693 
      return result.success
3694 
    if result.ex is not None:
3695 
      raise result.ex
3696 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3697 
 
4647 rajveer 3698 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3699 
    """
3700 
    Adds the given delay reason to the given order.
3986 chandransh 3701 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3702 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3703 
 
3553 chandransh 3704 
    Parameters:
3705 
     - orderId
3706 
     - delayReason
3986 chandransh 3707 
     - furtherDelay
4647 rajveer 3708 
     - delayReasonText
3553 chandransh 3709 
    """
4647 rajveer 3710 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3711 
    return self.recv_addDelayReason()
3712 
 
4647 rajveer 3713 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3714 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3715 
    args = addDelayReason_args()
3716 
    args.orderId = orderId
3717 
    args.delayReason = delayReason
3986 chandransh 3718 
    args.furtherDelay = furtherDelay
4647 rajveer 3719 
    args.delayReasonText = delayReasonText
3553 chandransh 3720 
    args.write(self._oprot)
3721 
    self._oprot.writeMessageEnd()
3722 
    self._oprot.trans.flush()
3723 
 
3724 
  def recv_addDelayReason(self, ):
3725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3726 
    if mtype == TMessageType.EXCEPTION:
3727 
      x = TApplicationException()
3728 
      x.read(self._iprot)
3729 
      self._iprot.readMessageEnd()
3730 
      raise x
3731 
    result = addDelayReason_result()
3732 
    result.read(self._iprot)
3733 
    self._iprot.readMessageEnd()
3734 
    if result.success is not None:
3735 
      return result.success
3736 
    if result.ex is not None:
3737 
      raise result.ex
3738 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
3739 
 
3956 chandransh 3740 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3741 
    """
3742 
    Marks the COD orders with given AWB nos. as having been processed.
3743 
    Updates the captured amount for the corresponding payment.
3553 chandransh 3744 
 
3956 chandransh 3745 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
3746 
    1. There is no order corresponding to an AWB number.
3747 
    2. The captured amount for a payment exceeds the total payment.
3748 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
3749 
 
3750 
    Parameters:
3751 
     - collectedAmountMap
3752 
     - xferBy
3753 
     - xferTxnId
3754 
     - xferDate
3755 
    """
3756 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
3757 
    return self.recv_reconcileCodCollection()
3758 
 
3759 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
3760 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
3761 
    args = reconcileCodCollection_args()
3762 
    args.collectedAmountMap = collectedAmountMap
3763 
    args.xferBy = xferBy
3764 
    args.xferTxnId = xferTxnId
3765 
    args.xferDate = xferDate
3766 
    args.write(self._oprot)
3767 
    self._oprot.writeMessageEnd()
3768 
    self._oprot.trans.flush()
3769 
 
3770 
  def recv_reconcileCodCollection(self, ):
3771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3772 
    if mtype == TMessageType.EXCEPTION:
3773 
      x = TApplicationException()
3774 
      x.read(self._iprot)
3775 
      self._iprot.readMessageEnd()
3776 
      raise x
3777 
    result = reconcileCodCollection_result()
3778 
    result.read(self._iprot)
3779 
    self._iprot.readMessageEnd()
3780 
    if result.success is not None:
3781 
      return result.success
3782 
    if result.ex is not None:
3783 
      raise result.ex
3784 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
3785 
 
4008 mandeep.dh 3786 
  def getTransactionsRequiringExtraProcessing(self, category):
3787 
    """
4065 mandeep.dh 3788 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 3789 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 3790 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 3791 
 
4008 mandeep.dh 3792 
    Parameters:
3793 
     - category
3794 
    """
3795 
    self.send_getTransactionsRequiringExtraProcessing(category)
3796 
    return self.recv_getTransactionsRequiringExtraProcessing()
3797 
 
3798 
  def send_getTransactionsRequiringExtraProcessing(self, category):
3799 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
3800 
    args = getTransactionsRequiringExtraProcessing_args()
3801 
    args.category = category
3802 
    args.write(self._oprot)
3803 
    self._oprot.writeMessageEnd()
3804 
    self._oprot.trans.flush()
3805 
 
3806 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
3807 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3808 
    if mtype == TMessageType.EXCEPTION:
3809 
      x = TApplicationException()
3810 
      x.read(self._iprot)
3811 
      self._iprot.readMessageEnd()
3812 
      raise x
3813 
    result = getTransactionsRequiringExtraProcessing_result()
3814 
    result.read(self._iprot)
3815 
    self._iprot.readMessageEnd()
3816 
    if result.success is not None:
3817 
      return result.success
3818 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
3819 
 
3820 
  def markTransactionAsProcessed(self, transactionId, category):
3821 
    """
3822 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 3823 
    It essentially deletes the transaction id record for a particular
3824 
    processing type category (if present) from DB.
3825 
    This is currently used by CRM application.
4008 mandeep.dh 3826 
 
3827 
    Parameters:
3828 
     - transactionId
3829 
     - category
3830 
    """
3831 
    self.send_markTransactionAsProcessed(transactionId, category)
3832 
    self.recv_markTransactionAsProcessed()
3833 
 
3834 
  def send_markTransactionAsProcessed(self, transactionId, category):
3835 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
3836 
    args = markTransactionAsProcessed_args()
3837 
    args.transactionId = transactionId
3838 
    args.category = category
3839 
    args.write(self._oprot)
3840 
    self._oprot.writeMessageEnd()
3841 
    self._oprot.trans.flush()
3842 
 
3843 
  def recv_markTransactionAsProcessed(self, ):
3844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3845 
    if mtype == TMessageType.EXCEPTION:
3846 
      x = TApplicationException()
3847 
      x.read(self._iprot)
3848 
      self._iprot.readMessageEnd()
3849 
      raise x
3850 
    result = markTransactionAsProcessed_result()
3851 
    result.read(self._iprot)
3852 
    self._iprot.readMessageEnd()
3853 
    return
3854 
 
4018 chandransh 3855 
  def getItemWiseRiskyOrdersCount(self, ):
3856 
    """
3857 
    Returns a map containing the number of risky orders keyed by item id. A risky order
3858 
    is defined as one whose shipping date is about to expire.
3859 
    """
3860 
    self.send_getItemWiseRiskyOrdersCount()
3861 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 3862 
 
4018 chandransh 3863 
  def send_getItemWiseRiskyOrdersCount(self, ):
3864 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
3865 
    args = getItemWiseRiskyOrdersCount_args()
3866 
    args.write(self._oprot)
3867 
    self._oprot.writeMessageEnd()
3868 
    self._oprot.trans.flush()
3869 
 
3870 
  def recv_getItemWiseRiskyOrdersCount(self, ):
3871 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3872 
    if mtype == TMessageType.EXCEPTION:
3873 
      x = TApplicationException()
3874 
      x.read(self._iprot)
3875 
      self._iprot.readMessageEnd()
3876 
      raise x
3877 
    result = getItemWiseRiskyOrdersCount_result()
3878 
    result.read(self._iprot)
3879 
    self._iprot.readMessageEnd()
3880 
    if result.success is not None:
3881 
      return result.success
3882 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
3883 
 
4295 varun.gupt 3884 
  def getOrdersForItemIds(self, itemIds):
3885 
    """
3886 
    Returns a list of all orders which have items with given id
3887 
 
3888 
    Parameters:
3889 
     - itemIds
3890 
    """
3891 
    self.send_getOrdersForItemIds(itemIds)
3892 
    return self.recv_getOrdersForItemIds()
3893 
 
3894 
  def send_getOrdersForItemIds(self, itemIds):
3895 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
3896 
    args = getOrdersForItemIds_args()
3897 
    args.itemIds = itemIds
3898 
    args.write(self._oprot)
3899 
    self._oprot.writeMessageEnd()
3900 
    self._oprot.trans.flush()
3901 
 
3902 
  def recv_getOrdersForItemIds(self, ):
3903 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3904 
    if mtype == TMessageType.EXCEPTION:
3905 
      x = TApplicationException()
3906 
      x.read(self._iprot)
3907 
      self._iprot.readMessageEnd()
3908 
      raise x
3909 
    result = getOrdersForItemIds_result()
3910 
    result.read(self._iprot)
3911 
    self._iprot.readMessageEnd()
3912 
    if result.success is not None:
3913 
      return result.success
3914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
3915 
 
4247 rajveer 3916 
  def markOrderCancellationRequestReceived(self, orderId):
3917 
    """
3918 
    Mark order as cancellation request received. If customer sends request of cancellation of
3919 
    a particular order, this method will be called. It will just change status of the order
3920 
    depending on its current status. It also records the previous status, so that we can move
3921 
    back to that status if cancellation request is denied.
4018 chandransh 3922 
 
4247 rajveer 3923 
    Parameters:
3924 
     - orderId
3925 
    """
3926 
    self.send_markOrderCancellationRequestReceived(orderId)
3927 
    self.recv_markOrderCancellationRequestReceived()
3928 
 
3929 
  def send_markOrderCancellationRequestReceived(self, orderId):
3930 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
3931 
    args = markOrderCancellationRequestReceived_args()
3932 
    args.orderId = orderId
3933 
    args.write(self._oprot)
3934 
    self._oprot.writeMessageEnd()
3935 
    self._oprot.trans.flush()
3936 
 
3937 
  def recv_markOrderCancellationRequestReceived(self, ):
3938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3939 
    if mtype == TMessageType.EXCEPTION:
3940 
      x = TApplicationException()
3941 
      x.read(self._iprot)
3942 
      self._iprot.readMessageEnd()
3943 
      raise x
3944 
    result = markOrderCancellationRequestReceived_result()
3945 
    result.read(self._iprot)
3946 
    self._iprot.readMessageEnd()
3947 
    if result.ex is not None:
3948 
      raise result.ex
3949 
    return
3950 
 
3951 
  def markOrderCancellationRequestConfirmed(self, orderId):
3952 
    """
3953 
    If we decide to to cancel order, CRM will call this method to move the status of order to
3954 
    cancellation request confirmed. After this OM will be able to cancel the order.
3955 
 
3956 
    Parameters:
3957 
     - orderId
3958 
    """
3959 
    self.send_markOrderCancellationRequestConfirmed(orderId)
3960 
    self.recv_markOrderCancellationRequestConfirmed()
3961 
 
3962 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
3963 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
3964 
    args = markOrderCancellationRequestConfirmed_args()
3965 
    args.orderId = orderId
3966 
    args.write(self._oprot)
3967 
    self._oprot.writeMessageEnd()
3968 
    self._oprot.trans.flush()
3969 
 
3970 
  def recv_markOrderCancellationRequestConfirmed(self, ):
3971 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3972 
    if mtype == TMessageType.EXCEPTION:
3973 
      x = TApplicationException()
3974 
      x.read(self._iprot)
3975 
      self._iprot.readMessageEnd()
3976 
      raise x
3977 
    result = markOrderCancellationRequestConfirmed_result()
3978 
    result.read(self._iprot)
3979 
    self._iprot.readMessageEnd()
3980 
    if result.ex is not None:
3981 
      raise result.ex
3982 
    return
3983 
 
3984 
  def markOrderCancellationRequestDenied(self, orderId):
3985 
    """
3986 
    If we decide to not to cancel order, we will move the order ro previous status.
3987 
 
3988 
    Parameters:
3989 
     - orderId
3990 
    """
3991 
    self.send_markOrderCancellationRequestDenied(orderId)
3992 
    self.recv_markOrderCancellationRequestDenied()
3993 
 
3994 
  def send_markOrderCancellationRequestDenied(self, orderId):
3995 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
3996 
    args = markOrderCancellationRequestDenied_args()
3997 
    args.orderId = orderId
3998 
    args.write(self._oprot)
3999 
    self._oprot.writeMessageEnd()
4000 
    self._oprot.trans.flush()
4001 
 
4002 
  def recv_markOrderCancellationRequestDenied(self, ):
4003 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4004 
    if mtype == TMessageType.EXCEPTION:
4005 
      x = TApplicationException()
4006 
      x.read(self._iprot)
4007 
      self._iprot.readMessageEnd()
4008 
      raise x
4009 
    result = markOrderCancellationRequestDenied_result()
4010 
    result.read(self._iprot)
4011 
    self._iprot.readMessageEnd()
4012 
    if result.ex is not None:
4013 
      raise result.ex
4014 
    return
4015 
 
4258 rajveer 4016 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4017 
    """
4258 rajveer 4018 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4019 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4020 
 
4021 
    Parameters:
4258 rajveer 4022 
     - transactionId
4247 rajveer 4023 
    """
4258 rajveer 4024 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4025 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4026 
 
4258 rajveer 4027 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4028 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4029 
    args = markTransactionAsPaymentFlagRemoved_args()
4030 
    args.transactionId = transactionId
4247 rajveer 4031 
    args.write(self._oprot)
4032 
    self._oprot.writeMessageEnd()
4033 
    self._oprot.trans.flush()
4034 
 
4258 rajveer 4035 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4036 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4037 
    if mtype == TMessageType.EXCEPTION:
4038 
      x = TApplicationException()
4039 
      x.read(self._iprot)
4040 
      self._iprot.readMessageEnd()
4041 
      raise x
4258 rajveer 4042 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4043 
    result.read(self._iprot)
4044 
    self._iprot.readMessageEnd()
4045 
    if result.ex is not None:
4046 
      raise result.ex
4047 
    return
4048 
 
4259 anupam.sin 4049 
  def refundTransaction(self, transactionId, refundedBy, reason):
4050 
    """
4051 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4052 
    need to be cancelled
4247 rajveer 4053 
 
4259 anupam.sin 4054 
    Parameters:
4055 
     - transactionId
4056 
     - refundedBy
4057 
     - reason
4058 
    """
4059 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4060 
    self.recv_refundTransaction()
4061 
 
4062 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4063 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4064 
    args = refundTransaction_args()
4065 
    args.transactionId = transactionId
4066 
    args.refundedBy = refundedBy
4067 
    args.reason = reason
4068 
    args.write(self._oprot)
4069 
    self._oprot.writeMessageEnd()
4070 
    self._oprot.trans.flush()
4071 
 
4072 
  def recv_refundTransaction(self, ):
4073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4074 
    if mtype == TMessageType.EXCEPTION:
4075 
      x = TApplicationException()
4076 
      x.read(self._iprot)
4077 
      self._iprot.readMessageEnd()
4078 
      raise x
4079 
    result = refundTransaction_result()
4080 
    result.read(self._iprot)
4081 
    self._iprot.readMessageEnd()
4082 
    if result.ex is not None:
4083 
      raise result.ex
4084 
    return
4085 
 
4324 mandeep.dh 4086 
  def updateShipmentAddress(self, orderId, addressId):
4087 
    """
4088 
    Updates shipment address of an order. Delivery and shipping date estimates
4089 
    etc. are also updated here.
4090 
 
4091 
    Throws TransactionServiceException in case address change is not
4092 
    possible due to certain reasons such as new pincode in address is
4093 
    not serviceable etc.
4094 
 
4095 
    Parameters:
4096 
     - orderId
4097 
     - addressId
4098 
    """
4099 
    self.send_updateShipmentAddress(orderId, addressId)
4100 
    self.recv_updateShipmentAddress()
4101 
 
4102 
  def send_updateShipmentAddress(self, orderId, addressId):
4103 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4104 
    args = updateShipmentAddress_args()
4105 
    args.orderId = orderId
4106 
    args.addressId = addressId
4107 
    args.write(self._oprot)
4108 
    self._oprot.writeMessageEnd()
4109 
    self._oprot.trans.flush()
4110 
 
4111 
  def recv_updateShipmentAddress(self, ):
4112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4113 
    if mtype == TMessageType.EXCEPTION:
4114 
      x = TApplicationException()
4115 
      x.read(self._iprot)
4116 
      self._iprot.readMessageEnd()
4117 
      raise x
4118 
    result = updateShipmentAddress_result()
4119 
    result.read(self._iprot)
4120 
    self._iprot.readMessageEnd()
4121 
    if result.ex is not None:
4122 
      raise result.ex
4123 
    return
4124 
 
4285 rajveer 4125 
  def acceptOrdersForItemId(self, itemId, inventory):
4126 
    """
4127 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4128 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4129 
 
4285 rajveer 4130 
    Parameters:
4131 
     - itemId
4132 
     - inventory
4133 
    """
4134 
    self.send_acceptOrdersForItemId(itemId, inventory)
4135 
    return self.recv_acceptOrdersForItemId()
4136 
 
4137 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4138 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4139 
    args = acceptOrdersForItemId_args()
4140 
    args.itemId = itemId
4141 
    args.inventory = inventory
4142 
    args.write(self._oprot)
4143 
    self._oprot.writeMessageEnd()
4144 
    self._oprot.trans.flush()
4145 
 
4146 
  def recv_acceptOrdersForItemId(self, ):
4147 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4148 
    if mtype == TMessageType.EXCEPTION:
4149 
      x = TApplicationException()
4150 
      x.read(self._iprot)
4151 
      self._iprot.readMessageEnd()
4152 
      raise x
4153 
    result = acceptOrdersForItemId_result()
4154 
    result.read(self._iprot)
4155 
    self._iprot.readMessageEnd()
4156 
    if result.success is not None:
4157 
      return result.success
4158 
    if result.ex is not None:
4159 
      raise result.ex
4160 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4161 
 
4369 rajveer 4162 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4163 
    """
4164 
    Parameters:
4165 
     - vendorId
4166 
     - itemId
4167 
     - quantity
4168 
     - estimate
4369 rajveer 4169 
     - isReminder
4303 rajveer 4170 
    """
4369 rajveer 4171 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4172 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4173 
 
4369 rajveer 4174 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4175 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4176 
    args = markOrdersAsPORaised_args()
4177 
    args.vendorId = vendorId
4178 
    args.itemId = itemId
4179 
    args.quantity = quantity
4180 
    args.estimate = estimate
4369 rajveer 4181 
    args.isReminder = isReminder
4303 rajveer 4182 
    args.write(self._oprot)
4183 
    self._oprot.writeMessageEnd()
4184 
    self._oprot.trans.flush()
4185 
 
4186 
  def recv_markOrdersAsPORaised(self, ):
4187 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4188 
    if mtype == TMessageType.EXCEPTION:
4189 
      x = TApplicationException()
4190 
      x.read(self._iprot)
4191 
      self._iprot.readMessageEnd()
4192 
      raise x
4193 
    result = markOrdersAsPORaised_result()
4194 
    result.read(self._iprot)
4195 
    self._iprot.readMessageEnd()
4196 
    if result.ex is not None:
4197 
      raise result.ex
4198 
    return
4199 
 
4369 rajveer 4200 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4201 
    """
4202 
    Parameters:
4203 
     - vendorId
4204 
     - itemId
4205 
     - quantity
4206 
     - estimate
4369 rajveer 4207 
     - isReminder
4303 rajveer 4208 
    """
4369 rajveer 4209 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4210 
    self.recv_markOrdersAsReversalInitiated()
4211 
 
4369 rajveer 4212 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4213 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4214 
    args = markOrdersAsReversalInitiated_args()
4215 
    args.vendorId = vendorId
4216 
    args.itemId = itemId
4217 
    args.quantity = quantity
4218 
    args.estimate = estimate
4369 rajveer 4219 
    args.isReminder = isReminder
4303 rajveer 4220 
    args.write(self._oprot)
4221 
    self._oprot.writeMessageEnd()
4222 
    self._oprot.trans.flush()
4223 
 
4224 
  def recv_markOrdersAsReversalInitiated(self, ):
4225 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4226 
    if mtype == TMessageType.EXCEPTION:
4227 
      x = TApplicationException()
4228 
      x.read(self._iprot)
4229 
      self._iprot.readMessageEnd()
4230 
      raise x
4231 
    result = markOrdersAsReversalInitiated_result()
4232 
    result.read(self._iprot)
4233 
    self._iprot.readMessageEnd()
4234 
    if result.ex is not None:
4235 
      raise result.ex
4236 
    return
4237 
 
4369 rajveer 4238 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4239 
    """
4240 
    Parameters:
4241 
     - vendorId
4242 
     - itemId
4243 
     - quantity
4244 
     - estimate
4369 rajveer 4245 
     - isReminder
4303 rajveer 4246 
    """
4369 rajveer 4247 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4248 
    self.recv_markOrdersAsNotAvailabke()
4249 
 
4369 rajveer 4250 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4251 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4252 
    args = markOrdersAsNotAvailabke_args()
4253 
    args.vendorId = vendorId
4254 
    args.itemId = itemId
4255 
    args.quantity = quantity
4256 
    args.estimate = estimate
4369 rajveer 4257 
    args.isReminder = isReminder
4303 rajveer 4258 
    args.write(self._oprot)
4259 
    self._oprot.writeMessageEnd()
4260 
    self._oprot.trans.flush()
4261 
 
4262 
  def recv_markOrdersAsNotAvailabke(self, ):
4263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4264 
    if mtype == TMessageType.EXCEPTION:
4265 
      x = TApplicationException()
4266 
      x.read(self._iprot)
4267 
      self._iprot.readMessageEnd()
4268 
      raise x
4269 
    result = markOrdersAsNotAvailabke_result()
4270 
    result.read(self._iprot)
4271 
    self._iprot.readMessageEnd()
4272 
    if result.ex is not None:
4273 
      raise result.ex
4274 
    return
4275 
 
4369 rajveer 4276 
  def markOrdersAsTimeout(self, vendorId):
4277 
    """
4278 
    Parameters:
4279 
     - vendorId
4280 
    """
4281 
    self.send_markOrdersAsTimeout(vendorId)
4282 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4283 
 
4369 rajveer 4284 
  def send_markOrdersAsTimeout(self, vendorId):
4285 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4286 
    args = markOrdersAsTimeout_args()
4287 
    args.vendorId = vendorId
4288 
    args.write(self._oprot)
4289 
    self._oprot.writeMessageEnd()
4290 
    self._oprot.trans.flush()
4291 
 
4292 
  def recv_markOrdersAsTimeout(self, ):
4293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4294 
    if mtype == TMessageType.EXCEPTION:
4295 
      x = TApplicationException()
4296 
      x.read(self._iprot)
4297 
      self._iprot.readMessageEnd()
4298 
      raise x
4299 
    result = markOrdersAsTimeout_result()
4300 
    result.read(self._iprot)
4301 
    self._iprot.readMessageEnd()
4302 
    if result.success is not None:
4303 
      return result.success
4304 
    if result.ex is not None:
4305 
      raise result.ex
4306 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4307 
 
4662 rajveer 4308 
  def markOrderAsLostInTransit(self, orderId):
4309 
    """
4310 
    Mark order as LOST_IN_TRANSIT
4311 
 
4312 
    Parameters:
4313 
     - orderId
4314 
    """
4315 
    self.send_markOrderAsLostInTransit(orderId)
4316 
    return self.recv_markOrderAsLostInTransit()
4317 
 
4318 
  def send_markOrderAsLostInTransit(self, orderId):
4319 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4320 
    args = markOrderAsLostInTransit_args()
4321 
    args.orderId = orderId
4322 
    args.write(self._oprot)
4323 
    self._oprot.writeMessageEnd()
4324 
    self._oprot.trans.flush()
4325 
 
4326 
  def recv_markOrderAsLostInTransit(self, ):
4327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4328 
    if mtype == TMessageType.EXCEPTION:
4329 
      x = TApplicationException()
4330 
      x.read(self._iprot)
4331 
      self._iprot.readMessageEnd()
4332 
      raise x
4333 
    result = markOrderAsLostInTransit_result()
4334 
    result.read(self._iprot)
4335 
    self._iprot.readMessageEnd()
4336 
    if result.success is not None:
4337 
      return result.success
4338 
    if result.ex is not None:
4339 
      raise result.ex
4340 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4341 
 
4386 anupam.sin 4342 
  def getOrderForAwb(self, awb):
4343 
    """
4344 
    Returns the order corresponding to an AWB number
4369 rajveer 4345 
 
4386 anupam.sin 4346 
    Parameters:
4347 
     - awb
4348 
    """
4349 
    self.send_getOrderForAwb(awb)
4350 
    return self.recv_getOrderForAwb()
4351 
 
4352 
  def send_getOrderForAwb(self, awb):
4353 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4354 
    args = getOrderForAwb_args()
4355 
    args.awb = awb
4356 
    args.write(self._oprot)
4357 
    self._oprot.writeMessageEnd()
4358 
    self._oprot.trans.flush()
4359 
 
4360 
  def recv_getOrderForAwb(self, ):
4361 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4362 
    if mtype == TMessageType.EXCEPTION:
4363 
      x = TApplicationException()
4364 
      x.read(self._iprot)
4365 
      self._iprot.readMessageEnd()
4366 
      raise x
4367 
    result = getOrderForAwb_result()
4368 
    result.read(self._iprot)
4369 
    self._iprot.readMessageEnd()
4370 
    if result.success is not None:
4371 
      return result.success
4372 
    if result.ex is not None:
4373 
      raise result.ex
4374 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4375 
 
4910 phani.kuma 4376 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4377 
    """
4910 phani.kuma 4378 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4379 
 
4506 phani.kuma 4380 
    Parameters:
4381 
     - logistics_provider_id
4910 phani.kuma 4382 
     - order_status_list
4506 phani.kuma 4383 
    """
4910 phani.kuma 4384 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4385 
    return self.recv_getOrdersForProviderForStatus()
4386 
 
4910 phani.kuma 4387 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4388 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4389 
    args = getOrdersForProviderForStatus_args()
4390 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4391 
    args.order_status_list = order_status_list
4506 phani.kuma 4392 
    args.write(self._oprot)
4393 
    self._oprot.writeMessageEnd()
4394 
    self._oprot.trans.flush()
4395 
 
4396 
  def recv_getOrdersForProviderForStatus(self, ):
4397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4398 
    if mtype == TMessageType.EXCEPTION:
4399 
      x = TApplicationException()
4400 
      x.read(self._iprot)
4401 
      self._iprot.readMessageEnd()
4402 
      raise x
4403 
    result = getOrdersForProviderForStatus_result()
4404 
    result.read(self._iprot)
4405 
    self._iprot.readMessageEnd()
4406 
    if result.success is not None:
4407 
      return result.success
4408 
    if result.ex is not None:
4409 
      raise result.ex
4410 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4411 
 
4600 varun.gupt 4412 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4413 
    """
4414 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4415 
 
4600 varun.gupt 4416 
    Parameters:
4417 
     - vendorId
4418 
     - billingDateFrom
4419 
     - billingDateTo
4420 
    """
4421 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4422 
    return self.recv_getBilledOrdersForVendor()
4423 
 
4424 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4425 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4426 
    args = getBilledOrdersForVendor_args()
4427 
    args.vendorId = vendorId
4428 
    args.billingDateFrom = billingDateFrom
4429 
    args.billingDateTo = billingDateTo
4430 
    args.write(self._oprot)
4431 
    self._oprot.writeMessageEnd()
4432 
    self._oprot.trans.flush()
4433 
 
4434 
  def recv_getBilledOrdersForVendor(self, ):
4435 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4436 
    if mtype == TMessageType.EXCEPTION:
4437 
      x = TApplicationException()
4438 
      x.read(self._iprot)
4439 
      self._iprot.readMessageEnd()
4440 
      raise x
4441 
    result = getBilledOrdersForVendor_result()
4442 
    result.read(self._iprot)
4443 
    self._iprot.readMessageEnd()
4444 
    if result.success is not None:
4445 
      return result.success
4446 
    if result.ex is not None:
4447 
      raise result.ex
4448 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4449 
 
4607 rajveer 4450 
  def getSlippedSippingDateOrders(self, ):
4451 
    self.send_getSlippedSippingDateOrders()
4452 
    return self.recv_getSlippedSippingDateOrders()
4453 
 
4454 
  def send_getSlippedSippingDateOrders(self, ):
4455 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4456 
    args = getSlippedSippingDateOrders_args()
4457 
    args.write(self._oprot)
4458 
    self._oprot.writeMessageEnd()
4459 
    self._oprot.trans.flush()
4460 
 
4461 
  def recv_getSlippedSippingDateOrders(self, ):
4462 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4463 
    if mtype == TMessageType.EXCEPTION:
4464 
      x = TApplicationException()
4465 
      x.read(self._iprot)
4466 
      self._iprot.readMessageEnd()
4467 
      raise x
4468 
    result = getSlippedSippingDateOrders_result()
4469 
    result.read(self._iprot)
4470 
    self._iprot.readMessageEnd()
4471 
    if result.success is not None:
4472 
      return result.success
4473 
    if result.ex is not None:
4474 
      raise result.ex
4475 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4476 
 
4709 rajveer 4477 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4478 
    """
4479 
    Parameters:
4480 
     - cancelDateFrom
4481 
     - cancelDateTo
4482 
    """
4483 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4484 
    return self.recv_getCancelledOrders()
4485 
 
4486 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4487 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4488 
    args = getCancelledOrders_args()
4489 
    args.cancelDateFrom = cancelDateFrom
4490 
    args.cancelDateTo = cancelDateTo
4491 
    args.write(self._oprot)
4492 
    self._oprot.writeMessageEnd()
4493 
    self._oprot.trans.flush()
4494 
 
4495 
  def recv_getCancelledOrders(self, ):
4496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4497 
    if mtype == TMessageType.EXCEPTION:
4498 
      x = TApplicationException()
4499 
      x.read(self._iprot)
4500 
      self._iprot.readMessageEnd()
4501 
      raise x
4502 
    result = getCancelledOrders_result()
4503 
    result.read(self._iprot)
4504 
    self._iprot.readMessageEnd()
4505 
    if result.success is not None:
4506 
      return result.success
4507 
    if result.ex is not None:
4508 
      raise result.ex
4509 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4510 
 
4600 varun.gupt 4511 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4512 
    """
4513 
    Parameters:
4514 
     - mapAWBAndAmount
4515 
    """
4516 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4517 
    self.recv_saveBluedartSettlements()
4518 
 
4519 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4520 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4521 
    args = saveBluedartSettlements_args()
4522 
    args.mapAWBAndAmount = mapAWBAndAmount
4523 
    args.write(self._oprot)
4524 
    self._oprot.writeMessageEnd()
4525 
    self._oprot.trans.flush()
4526 
 
4527 
  def recv_saveBluedartSettlements(self, ):
4528 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4529 
    if mtype == TMessageType.EXCEPTION:
4530 
      x = TApplicationException()
4531 
      x.read(self._iprot)
4532 
      self._iprot.readMessageEnd()
4533 
      raise x
4534 
    result = saveBluedartSettlements_result()
4535 
    result.read(self._iprot)
4536 
    self._iprot.readMessageEnd()
4537 
    if result.ex is not None:
4538 
      raise result.ex
4539 
    return
4540 
 
4905 varun.gupt 4541 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4542 
    """
4543 
    Parameters:
4544 
     - settlementDate
4545 
     - paymentGatewayId
4905 varun.gupt 4546 
     - referenceId
4600 varun.gupt 4547 
     - serviceTax
4548 
     - otherCharges
4549 
     - netCollection
4550 
    """
4905 varun.gupt 4551 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4552 
    self.recv_savePaymentSettlements()
4553 
 
4905 varun.gupt 4554 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4555 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4556 
    args = savePaymentSettlements_args()
4557 
    args.settlementDate = settlementDate
4558 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4559 
    args.referenceId = referenceId
4600 varun.gupt 4560 
    args.serviceTax = serviceTax
4561 
    args.otherCharges = otherCharges
4562 
    args.netCollection = netCollection
4563 
    args.write(self._oprot)
4564 
    self._oprot.writeMessageEnd()
4565 
    self._oprot.trans.flush()
4566 
 
4567 
  def recv_savePaymentSettlements(self, ):
4568 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4569 
    if mtype == TMessageType.EXCEPTION:
4570 
      x = TApplicationException()
4571 
      x.read(self._iprot)
4572 
      self._iprot.readMessageEnd()
4573 
      raise x
4574 
    result = savePaymentSettlements_result()
4575 
    result.read(self._iprot)
4576 
    self._iprot.readMessageEnd()
4577 
    if result.ex is not None:
4578 
      raise result.ex
4579 
    return
4580 
 
4581 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4582 
    """
4583 
    Parameters:
4584 
     - settlementId
4585 
     - settlementDate
4586 
     - transactionDateFrom
4587 
     - transactionDateTo
4588 
     - amount
4589 
    """
4590 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4591 
    self.recv_saveEBSSettlementSummary()
4592 
 
4593 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4594 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4595 
    args = saveEBSSettlementSummary_args()
4596 
    args.settlementId = settlementId
4597 
    args.settlementDate = settlementDate
4598 
    args.transactionDateFrom = transactionDateFrom
4599 
    args.transactionDateTo = transactionDateTo
4600 
    args.amount = amount
4601 
    args.write(self._oprot)
4602 
    self._oprot.writeMessageEnd()
4603 
    self._oprot.trans.flush()
4604 
 
4605 
  def recv_saveEBSSettlementSummary(self, ):
4606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4607 
    if mtype == TMessageType.EXCEPTION:
4608 
      x = TApplicationException()
4609 
      x.read(self._iprot)
4610 
      self._iprot.readMessageEnd()
4611 
      raise x
4612 
    result = saveEBSSettlementSummary_result()
4613 
    result.read(self._iprot)
4614 
    self._iprot.readMessageEnd()
4615 
    if result.ex is not None:
4616 
      raise result.ex
4617 
    return
4618 
 
5189 varun.gupt 4619 
  def getSettlementForReferenceId(self, referenceId, isRefund):
4600 varun.gupt 4620 
    """
4621 
    Parameters:
5189 varun.gupt 4622 
     - referenceId
4623 
     - isRefund
4600 varun.gupt 4624 
    """
5189 varun.gupt 4625 
    self.send_getSettlementForReferenceId(referenceId, isRefund)
4626 
    return self.recv_getSettlementForReferenceId()
4600 varun.gupt 4627 
 
5189 varun.gupt 4628 
  def send_getSettlementForReferenceId(self, referenceId, isRefund):
4629 
    self._oprot.writeMessageBegin('getSettlementForReferenceId', TMessageType.CALL, self._seqid)
4630 
    args = getSettlementForReferenceId_args()
4631 
    args.referenceId = referenceId
4632 
    args.isRefund = isRefund
4600 varun.gupt 4633 
    args.write(self._oprot)
4634 
    self._oprot.writeMessageEnd()
4635 
    self._oprot.trans.flush()
4636 
 
5189 varun.gupt 4637 
  def recv_getSettlementForReferenceId(self, ):
4600 varun.gupt 4638 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4639 
    if mtype == TMessageType.EXCEPTION:
4640 
      x = TApplicationException()
4641 
      x.read(self._iprot)
4642 
      self._iprot.readMessageEnd()
4643 
      raise x
5189 varun.gupt 4644 
    result = getSettlementForReferenceId_result()
4600 varun.gupt 4645 
    result.read(self._iprot)
4646 
    self._iprot.readMessageEnd()
4647 
    if result.success is not None:
4648 
      return result.success
4649 
    if result.ex is not None:
4650 
      raise result.ex
5189 varun.gupt 4651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForReferenceId failed: unknown result");
4600 varun.gupt 4652 
 
4653 
  def getEBSSettlementSummaries(self, ):
4654 
    self.send_getEBSSettlementSummaries()
4655 
    return self.recv_getEBSSettlementSummaries()
4656 
 
4657 
  def send_getEBSSettlementSummaries(self, ):
4658 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4659 
    args = getEBSSettlementSummaries_args()
4660 
    args.write(self._oprot)
4661 
    self._oprot.writeMessageEnd()
4662 
    self._oprot.trans.flush()
4663 
 
4664 
  def recv_getEBSSettlementSummaries(self, ):
4665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4666 
    if mtype == TMessageType.EXCEPTION:
4667 
      x = TApplicationException()
4668 
      x.read(self._iprot)
4669 
      self._iprot.readMessageEnd()
4670 
      raise x
4671 
    result = getEBSSettlementSummaries_result()
4672 
    result.read(self._iprot)
4673 
    self._iprot.readMessageEnd()
4674 
    if result.success is not None:
4675 
      return result.success
4676 
    if result.ex is not None:
4677 
      raise result.ex
4678 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4679 
 
4680 
  def markEBSSettlementUploaded(self, settlementId):
4681 
    """
4682 
    Parameters:
4683 
     - settlementId
4684 
    """
4685 
    self.send_markEBSSettlementUploaded(settlementId)
4686 
    self.recv_markEBSSettlementUploaded()
4687 
 
4688 
  def send_markEBSSettlementUploaded(self, settlementId):
4689 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4690 
    args = markEBSSettlementUploaded_args()
4691 
    args.settlementId = settlementId
4692 
    args.write(self._oprot)
4693 
    self._oprot.writeMessageEnd()
4694 
    self._oprot.trans.flush()
4695 
 
4696 
  def recv_markEBSSettlementUploaded(self, ):
4697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4698 
    if mtype == TMessageType.EXCEPTION:
4699 
      x = TApplicationException()
4700 
      x.read(self._iprot)
4701 
      self._iprot.readMessageEnd()
4702 
      raise x
4703 
    result = markEBSSettlementUploaded_result()
4704 
    result.read(self._iprot)
4705 
    self._iprot.readMessageEnd()
4706 
    if result.ex is not None:
4707 
      raise result.ex
4708 
    return
4709 
 
4710 
  def getEBSSettlementDate(self, settlementId):
4711 
    """
4712 
    Parameters:
4713 
     - settlementId
4714 
    """
4715 
    self.send_getEBSSettlementDate(settlementId)
4716 
    return self.recv_getEBSSettlementDate()
4717 
 
4718 
  def send_getEBSSettlementDate(self, settlementId):
4719 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
4720 
    args = getEBSSettlementDate_args()
4721 
    args.settlementId = settlementId
4722 
    args.write(self._oprot)
4723 
    self._oprot.writeMessageEnd()
4724 
    self._oprot.trans.flush()
4725 
 
4726 
  def recv_getEBSSettlementDate(self, ):
4727 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4728 
    if mtype == TMessageType.EXCEPTION:
4729 
      x = TApplicationException()
4730 
      x.read(self._iprot)
4731 
      self._iprot.readMessageEnd()
4732 
      raise x
4733 
    result = getEBSSettlementDate_result()
4734 
    result.read(self._iprot)
4735 
    self._iprot.readMessageEnd()
4736 
    if result.success is not None:
4737 
      return result.success
4738 
    if result.ex is not None:
4739 
      raise result.ex
4740 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
4741 
 
4715 varun.gupt 4742 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4743 
    """
4744 
    Parameters:
4745 
     - settlementDateFrom
4746 
     - settlementDateTo
4747 
     - isRefund
4748 
    """
4749 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
4750 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 4751 
 
4715 varun.gupt 4752 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
4753 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
4754 
    args = getSettlementsByDate_args()
4755 
    args.settlementDateFrom = settlementDateFrom
4756 
    args.settlementDateTo = settlementDateTo
4757 
    args.isRefund = isRefund
4758 
    args.write(self._oprot)
4759 
    self._oprot.writeMessageEnd()
4760 
    self._oprot.trans.flush()
4761 
 
4762 
  def recv_getSettlementsByDate(self, ):
4763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4764 
    if mtype == TMessageType.EXCEPTION:
4765 
      x = TApplicationException()
4766 
      x.read(self._iprot)
4767 
      self._iprot.readMessageEnd()
4768 
      raise x
4769 
    result = getSettlementsByDate_result()
4770 
    result.read(self._iprot)
4771 
    self._iprot.readMessageEnd()
4772 
    if result.success is not None:
4773 
      return result.success
4774 
    if result.ex is not None:
4775 
      raise result.ex
4776 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
4777 
 
4778 
  def getReshippedOrderIds(self, orderIds):
4779 
    """
4780 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
4781 
 
4782 
    Parameters:
4783 
     - orderIds
4784 
    """
4785 
    self.send_getReshippedOrderIds(orderIds)
4786 
    return self.recv_getReshippedOrderIds()
4787 
 
4788 
  def send_getReshippedOrderIds(self, orderIds):
4789 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
4790 
    args = getReshippedOrderIds_args()
4791 
    args.orderIds = orderIds
4792 
    args.write(self._oprot)
4793 
    self._oprot.writeMessageEnd()
4794 
    self._oprot.trans.flush()
4795 
 
4796 
  def recv_getReshippedOrderIds(self, ):
4797 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4798 
    if mtype == TMessageType.EXCEPTION:
4799 
      x = TApplicationException()
4800 
      x.read(self._iprot)
4801 
      self._iprot.readMessageEnd()
4802 
      raise x
4803 
    result = getReshippedOrderIds_result()
4804 
    result.read(self._iprot)
4805 
    self._iprot.readMessageEnd()
4806 
    if result.success is not None:
4807 
      return result.success
4808 
    if result.ex is not None:
4809 
      raise result.ex
4810 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
4811 
 
4757 mandeep.dh 4812 
  def updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4813 
    """
4814 
    Updates orders as PO raised. Also updates purchase order id in orders. Pass a map of items mapped to
4815 
    the quantities for which the PO is raised.
4715 varun.gupt 4816 
 
4757 mandeep.dh 4817 
    Parameters:
4818 
     - itemIdQuantityMap
4819 
     - purchaseOrderId
4820 
     - warehouseId
4821 
    """
4822 
    self.send_updateOrdersAsPORaised(itemIdQuantityMap, purchaseOrderId, warehouseId)
4823 
    self.recv_updateOrdersAsPORaised()
4824 
 
4825 
  def send_updateOrdersAsPORaised(self, itemIdQuantityMap, purchaseOrderId, warehouseId):
4826 
    self._oprot.writeMessageBegin('updateOrdersAsPORaised', TMessageType.CALL, self._seqid)
4827 
    args = updateOrdersAsPORaised_args()
4828 
    args.itemIdQuantityMap = itemIdQuantityMap
4829 
    args.purchaseOrderId = purchaseOrderId
4830 
    args.warehouseId = warehouseId
4831 
    args.write(self._oprot)
4832 
    self._oprot.writeMessageEnd()
4833 
    self._oprot.trans.flush()
4834 
 
4835 
  def recv_updateOrdersAsPORaised(self, ):
4836 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4837 
    if mtype == TMessageType.EXCEPTION:
4838 
      x = TApplicationException()
4839 
      x.read(self._iprot)
4840 
      self._iprot.readMessageEnd()
4841 
      raise x
4842 
    result = updateOrdersAsPORaised_result()
4843 
    result.read(self._iprot)
4844 
    self._iprot.readMessageEnd()
4845 
    if result.ex is not None:
4846 
      raise result.ex
4847 
    return
4848 
 
4875 varun.gupt 4849 
  def getOrdersWhereVendorNotPaid(self, vendorId):
4850 
    """
4851 
    Parameters:
4852 
     - vendorId
4853 
    """
4854 
    self.send_getOrdersWhereVendorNotPaid(vendorId)
4855 
    return self.recv_getOrdersWhereVendorNotPaid()
4757 mandeep.dh 4856 
 
4875 varun.gupt 4857 
  def send_getOrdersWhereVendorNotPaid(self, vendorId):
4858 
    self._oprot.writeMessageBegin('getOrdersWhereVendorNotPaid', TMessageType.CALL, self._seqid)
4859 
    args = getOrdersWhereVendorNotPaid_args()
4860 
    args.vendorId = vendorId
4861 
    args.write(self._oprot)
4862 
    self._oprot.writeMessageEnd()
4863 
    self._oprot.trans.flush()
4864 
 
4865 
  def recv_getOrdersWhereVendorNotPaid(self, ):
4866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4867 
    if mtype == TMessageType.EXCEPTION:
4868 
      x = TApplicationException()
4869 
      x.read(self._iprot)
4870 
      self._iprot.readMessageEnd()
4871 
      raise x
4872 
    result = getOrdersWhereVendorNotPaid_result()
4873 
    result.read(self._iprot)
4874 
    self._iprot.readMessageEnd()
4875 
    if result.success is not None:
4876 
      return result.success
4877 
    if result.ex is not None:
4878 
      raise result.ex
4879 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersWhereVendorNotPaid failed: unknown result");
4880 
 
5031 varun.gupt 4881 
  def getStatusDistributionOfOrders(self, startDate, endDate):
4882 
    """
4883 
    Parameters:
4884 
     - startDate
4885 
     - endDate
4886 
    """
4887 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
4888 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 4889 
 
5031 varun.gupt 4890 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
4891 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
4892 
    args = getStatusDistributionOfOrders_args()
4893 
    args.startDate = startDate
4894 
    args.endDate = endDate
4895 
    args.write(self._oprot)
4896 
    self._oprot.writeMessageEnd()
4897 
    self._oprot.trans.flush()
4898 
 
4899 
  def recv_getStatusDistributionOfOrders(self, ):
4900 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4901 
    if mtype == TMessageType.EXCEPTION:
4902 
      x = TApplicationException()
4903 
      x.read(self._iprot)
4904 
      self._iprot.readMessageEnd()
4905 
      raise x
4906 
    result = getStatusDistributionOfOrders_result()
4907 
    result.read(self._iprot)
4908 
    self._iprot.readMessageEnd()
4909 
    if result.success is not None:
4910 
      return result.success
4911 
    if result.ex is not None:
4912 
      raise result.ex
4913 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
4914 
 
5067 varun.gupt 4915 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
4916 
    """
4917 
    Parameters:
4918 
     - status
4919 
     - startDatetime
4920 
     - endDatetime
4921 
    """
4922 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
4923 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 4924 
 
5067 varun.gupt 4925 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
4926 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
4927 
    args = getOrderIdsForStatus_args()
4928 
    args.status = status
4929 
    args.startDatetime = startDatetime
4930 
    args.endDatetime = endDatetime
4931 
    args.write(self._oprot)
4932 
    self._oprot.writeMessageEnd()
4933 
    self._oprot.trans.flush()
4934 
 
4935 
  def recv_getOrderIdsForStatus(self, ):
4936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4937 
    if mtype == TMessageType.EXCEPTION:
4938 
      x = TApplicationException()
4939 
      x.read(self._iprot)
4940 
      self._iprot.readMessageEnd()
4941 
      raise x
4942 
    result = getOrderIdsForStatus_result()
4943 
    result.read(self._iprot)
4944 
    self._iprot.readMessageEnd()
4945 
    if result.success is not None:
4946 
      return result.success
4947 
    if result.ex is not None:
4948 
      raise result.ex
4949 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
4950 
 
5099 varun.gupt 4951 
  def updateOrderAsPaidToVendor(self, orderId):
4952 
    """
4953 
    Parameters:
4954 
     - orderId
4955 
    """
4956 
    self.send_updateOrderAsPaidToVendor(orderId)
4957 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 4958 
 
5099 varun.gupt 4959 
  def send_updateOrderAsPaidToVendor(self, orderId):
4960 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
4961 
    args = updateOrderAsPaidToVendor_args()
4962 
    args.orderId = orderId
4963 
    args.write(self._oprot)
4964 
    self._oprot.writeMessageEnd()
4965 
    self._oprot.trans.flush()
4966 
 
4967 
  def recv_updateOrderAsPaidToVendor(self, ):
4968 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4969 
    if mtype == TMessageType.EXCEPTION:
4970 
      x = TApplicationException()
4971 
      x.read(self._iprot)
4972 
      self._iprot.readMessageEnd()
4973 
      raise x
4974 
    result = updateOrderAsPaidToVendor_result()
4975 
    result.read(self._iprot)
4976 
    self._iprot.readMessageEnd()
4977 
    if result.ex is not None:
4978 
      raise result.ex
4979 
    return
4980 
 
5208 varun.gupt 4981 
  def getRefundedOrdersMarkedPaid(self, ):
4982 
    self.send_getRefundedOrdersMarkedPaid()
4983 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 4984 
 
5208 varun.gupt 4985 
  def send_getRefundedOrdersMarkedPaid(self, ):
4986 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
4987 
    args = getRefundedOrdersMarkedPaid_args()
4988 
    args.write(self._oprot)
4989 
    self._oprot.writeMessageEnd()
4990 
    self._oprot.trans.flush()
4991 
 
4992 
  def recv_getRefundedOrdersMarkedPaid(self, ):
4993 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4994 
    if mtype == TMessageType.EXCEPTION:
4995 
      x = TApplicationException()
4996 
      x.read(self._iprot)
4997 
      self._iprot.readMessageEnd()
4998 
      raise x
4999 
    result = getRefundedOrdersMarkedPaid_result()
5000 
    result.read(self._iprot)
5001 
    self._iprot.readMessageEnd()
5002 
    if result.success is not None:
5003 
      return result.success
5004 
    if result.ex is not None:
5005 
      raise result.ex
5006 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5007 
 
5008 
 
3376 rajveer 5009 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 5010 
  def __init__(self, handler):
3376 rajveer 5011 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 5012 
    self._processMap["createTransaction"] = Processor.process_createTransaction
5013 
    self._processMap["getTransaction"] = Processor.process_getTransaction
5014 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 5015 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 5016 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
5017 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 5018 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 5019 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 5020 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
5021 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 5022 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 5023 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 5024 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
5025 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 5026 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
5027 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
5028 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
5029 
    self._processMap["createOrder"] = Processor.process_createOrder
5030 
    self._processMap["getOrder"] = Processor.process_getOrder
5031 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 5032 
    self._processMap["getOrderList"] = Processor.process_getOrderList
1528 ankur.sing 5033 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 5034 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 5035 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 5036 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 5037 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
5038 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
5039 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
5040 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 5041 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 5042 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 5043 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
5044 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
5045 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 5046 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 5047 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
1113 chandransh 5048 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 5049 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 5050 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 5051 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
5052 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 5053 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 5054 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
5055 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
5056 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
5057 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
5058 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 5059 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 5060 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 5061 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 5062 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
4454 rajveer 5063 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
5064 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 5065 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
5066 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 5067 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
5068 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 5069 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 5070 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 5071 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 5072 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 5073 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 5074 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 5075 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 5076 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
5077 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 5078 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 5079 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 5080 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 5081 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 5082 
    self._processMap["changeItem"] = Processor.process_changeItem
5083 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 5084 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 5085 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 5086 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
5087 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 5088 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 5089 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 5090 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
5091 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
5092 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 5093 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 5094 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 5095 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 5096 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 5097 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
5098 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
5099 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 5100 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 5101 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 5102 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 5103 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 5104 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 5105 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 5106 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 5107 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
5108 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
5109 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5189 varun.gupt 5110 
    self._processMap["getSettlementForReferenceId"] = Processor.process_getSettlementForReferenceId
4600 varun.gupt 5111 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
5112 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
5113 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 5114 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
5115 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
4757 mandeep.dh 5116 
    self._processMap["updateOrdersAsPORaised"] = Processor.process_updateOrdersAsPORaised
4875 varun.gupt 5117 
    self._processMap["getOrdersWhereVendorNotPaid"] = Processor.process_getOrdersWhereVendorNotPaid
5031 varun.gupt 5118 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 5119 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5099 varun.gupt 5120 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5208 varun.gupt 5121 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
94 ashish 5122 
 
5123 
  def process(self, iprot, oprot):
5124 
    (name, type, seqid) = iprot.readMessageBegin()
5125 
    if name not in self._processMap:
5126 
      iprot.skip(TType.STRUCT)
5127 
      iprot.readMessageEnd()
5128 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5129 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5130 
      x.write(oprot)
5131 
      oprot.writeMessageEnd()
5132 
      oprot.trans.flush()
5133 
      return
5134 
    else:
5135 
      self._processMap[name](self, seqid, iprot, oprot)
5136 
    return True
5137 
 
5138 
  def process_createTransaction(self, seqid, iprot, oprot):
5139 
    args = createTransaction_args()
5140 
    args.read(iprot)
5141 
    iprot.readMessageEnd()
5142 
    result = createTransaction_result()
5143 
    try:
132 ashish 5144 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 5145 
    except TransactionServiceException, ex:
5146 
      result.ex = ex
5147 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
5148 
    result.write(oprot)
5149 
    oprot.writeMessageEnd()
5150 
    oprot.trans.flush()
5151 
 
5152 
  def process_getTransaction(self, seqid, iprot, oprot):
5153 
    args = getTransaction_args()
5154 
    args.read(iprot)
5155 
    iprot.readMessageEnd()
5156 
    result = getTransaction_result()
5157 
    try:
5158 
      result.success = self._handler.getTransaction(args.id)
5159 
    except TransactionServiceException, ex:
5160 
      result.ex = ex
5161 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
5162 
    result.write(oprot)
5163 
    oprot.writeMessageEnd()
5164 
    oprot.trans.flush()
5165 
 
5166 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
5167 
    args = getTransactionsForCustomer_args()
5168 
    args.read(iprot)
5169 
    iprot.readMessageEnd()
5170 
    result = getTransactionsForCustomer_result()
5171 
    try:
5172 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
5173 
    except TransactionServiceException, ex:
5174 
      result.ex = ex
5175 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
5176 
    result.write(oprot)
5177 
    oprot.writeMessageEnd()
5178 
    oprot.trans.flush()
5179 
 
132 ashish 5180 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
5181 
    args = getTransactionsForShoppingCartId_args()
5182 
    args.read(iprot)
5183 
    iprot.readMessageEnd()
5184 
    result = getTransactionsForShoppingCartId_result()
5185 
    try:
5186 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
5187 
    except TransactionServiceException, ex:
5188 
      result.ex = ex
5189 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
5190 
    result.write(oprot)
5191 
    oprot.writeMessageEnd()
5192 
    oprot.trans.flush()
5193 
 
94 ashish 5194 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
5195 
    args = getTransactionStatus_args()
5196 
    args.read(iprot)
5197 
    iprot.readMessageEnd()
5198 
    result = getTransactionStatus_result()
5199 
    try:
5200 
      result.success = self._handler.getTransactionStatus(args.transactionId)
5201 
    except TransactionServiceException, ex:
5202 
      result.ex = ex
5203 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
5204 
    result.write(oprot)
5205 
    oprot.writeMessageEnd()
5206 
    oprot.trans.flush()
5207 
 
5208 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
5209 
    args = changeTransactionStatus_args()
5210 
    args.read(iprot)
5211 
    iprot.readMessageEnd()
5212 
    result = changeTransactionStatus_result()
5213 
    try:
5214 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
5215 
    except TransactionServiceException, ex:
5216 
      result.ex = ex
5217 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
5218 
    result.write(oprot)
5219 
    oprot.writeMessageEnd()
5220 
    oprot.trans.flush()
5221 
 
1398 varun.gupt 5222 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
5223 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 5224 
    args.read(iprot)
5225 
    iprot.readMessageEnd()
1398 varun.gupt 5226 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 5227 
    try:
1398 varun.gupt 5228 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 5229 
    except TransactionServiceException, ex:
5230 
      result.ex = ex
1398 varun.gupt 5231 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 5232 
    result.write(oprot)
5233 
    oprot.writeMessageEnd()
5234 
    oprot.trans.flush()
5235 
 
483 rajveer 5236 
  def process_getAllOrders(self, seqid, iprot, oprot):
5237 
    args = getAllOrders_args()
94 ashish 5238 
    args.read(iprot)
5239 
    iprot.readMessageEnd()
483 rajveer 5240 
    result = getAllOrders_result()
94 ashish 5241 
    try:
4801 anupam.sin 5242 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 5243 
    except TransactionServiceException, ex:
5244 
      result.ex = ex
483 rajveer 5245 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 5246 
    result.write(oprot)
5247 
    oprot.writeMessageEnd()
5248 
    oprot.trans.flush()
5249 
 
4133 chandransh 5250 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
5251 
    args = getOrdersInBatch_args()
5252 
    args.read(iprot)
5253 
    iprot.readMessageEnd()
5254 
    result = getOrdersInBatch_result()
5255 
    try:
5256 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
5257 
    except TransactionServiceException, ex:
5258 
      result.ex = ex
5259 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
5260 
    result.write(oprot)
5261 
    oprot.writeMessageEnd()
5262 
    oprot.trans.flush()
5263 
 
5264 
  def process_getOrderCount(self, seqid, iprot, oprot):
5265 
    args = getOrderCount_args()
5266 
    args.read(iprot)
5267 
    iprot.readMessageEnd()
5268 
    result = getOrderCount_result()
5269 
    try:
5270 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
5271 
    except TransactionServiceException, ex:
5272 
      result.ex = ex
5273 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
5274 
    result.write(oprot)
5275 
    oprot.writeMessageEnd()
5276 
    oprot.trans.flush()
5277 
 
999 varun.gupt 5278 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
5279 
    args = getOrdersByBillingDate_args()
5280 
    args.read(iprot)
5281 
    iprot.readMessageEnd()
5282 
    result = getOrdersByBillingDate_result()
5283 
    try:
5284 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
5285 
    except TransactionServiceException, ex:
5286 
      result.ex = ex
5287 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
5288 
    result.write(oprot)
5289 
    oprot.writeMessageEnd()
5290 
    oprot.trans.flush()
5291 
 
3427 chandransh 5292 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
5293 
    args = getOrdersByShippingDate_args()
5294 
    args.read(iprot)
5295 
    iprot.readMessageEnd()
5296 
    result = getOrdersByShippingDate_result()
5297 
    try:
3451 chandransh 5298 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 5299 
    except TransactionServiceException, ex:
5300 
      result.ex = ex
5301 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
5302 
    result.write(oprot)
5303 
    oprot.writeMessageEnd()
5304 
    oprot.trans.flush()
5305 
 
1382 varun.gupt 5306 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
5307 
    args = getReturnableOrdersForCustomer_args()
5308 
    args.read(iprot)
5309 
    iprot.readMessageEnd()
5310 
    result = getReturnableOrdersForCustomer_result()
5311 
    try:
5312 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
5313 
    except TransactionServiceException, ex:
5314 
      result.ex = ex
5315 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
5316 
    result.write(oprot)
5317 
    oprot.writeMessageEnd()
5318 
    oprot.trans.flush()
5319 
 
5320 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
5321 
    args = getCancellableOrdersForCustomer_args()
5322 
    args.read(iprot)
5323 
    iprot.readMessageEnd()
5324 
    result = getCancellableOrdersForCustomer_result()
5325 
    try:
5326 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
5327 
    except TransactionServiceException, ex:
5328 
      result.ex = ex
5329 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
5330 
    result.write(oprot)
5331 
    oprot.writeMessageEnd()
5332 
    oprot.trans.flush()
5333 
 
483 rajveer 5334 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
5335 
    args = changeOrderStatus_args()
94 ashish 5336 
    args.read(iprot)
5337 
    iprot.readMessageEnd()
483 rajveer 5338 
    result = changeOrderStatus_result()
94 ashish 5339 
    try:
483 rajveer 5340 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 5341 
    except TransactionServiceException, ex:
5342 
      result.ex = ex
483 rajveer 5343 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 5344 
    result.write(oprot)
5345 
    oprot.writeMessageEnd()
5346 
    oprot.trans.flush()
5347 
 
483 rajveer 5348 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
5349 
    args = getOrdersForTransaction_args()
94 ashish 5350 
    args.read(iprot)
5351 
    iprot.readMessageEnd()
483 rajveer 5352 
    result = getOrdersForTransaction_result()
94 ashish 5353 
    try:
1528 ankur.sing 5354 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 5355 
    except TransactionServiceException, ex:
5356 
      result.ex = ex
483 rajveer 5357 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 5358 
    result.write(oprot)
5359 
    oprot.writeMessageEnd()
5360 
    oprot.trans.flush()
5361 
 
483 rajveer 5362 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
5363 
    args = getOrdersForCustomer_args()
94 ashish 5364 
    args.read(iprot)
5365 
    iprot.readMessageEnd()
483 rajveer 5366 
    result = getOrdersForCustomer_result()
94 ashish 5367 
    try:
3014 chandransh 5368 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 5369 
    except TransactionServiceException, ex:
5370 
      result.ex = ex
483 rajveer 5371 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 5372 
    result.write(oprot)
5373 
    oprot.writeMessageEnd()
5374 
    oprot.trans.flush()
5375 
 
483 rajveer 5376 
  def process_createOrder(self, seqid, iprot, oprot):
5377 
    args = createOrder_args()
94 ashish 5378 
    args.read(iprot)
5379 
    iprot.readMessageEnd()
483 rajveer 5380 
    result = createOrder_result()
94 ashish 5381 
    try:
483 rajveer 5382 
      result.success = self._handler.createOrder(args.order)
94 ashish 5383 
    except TransactionServiceException, ex:
5384 
      result.ex = ex
483 rajveer 5385 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 5386 
    result.write(oprot)
5387 
    oprot.writeMessageEnd()
5388 
    oprot.trans.flush()
5389 
 
483 rajveer 5390 
  def process_getOrder(self, seqid, iprot, oprot):
5391 
    args = getOrder_args()
94 ashish 5392 
    args.read(iprot)
5393 
    iprot.readMessageEnd()
483 rajveer 5394 
    result = getOrder_result()
94 ashish 5395 
    try:
483 rajveer 5396 
      result.success = self._handler.getOrder(args.id)
94 ashish 5397 
    except TransactionServiceException, ex:
5398 
      result.ex = ex
483 rajveer 5399 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 5400 
    result.write(oprot)
5401 
    oprot.writeMessageEnd()
5402 
    oprot.trans.flush()
5403 
 
483 rajveer 5404 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
5405 
    args = getLineItemsForOrder_args()
94 ashish 5406 
    args.read(iprot)
5407 
    iprot.readMessageEnd()
483 rajveer 5408 
    result = getLineItemsForOrder_result()
94 ashish 5409 
    try:
483 rajveer 5410 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 5411 
    except TransactionServiceException, ex:
5412 
      result.ex = ex
483 rajveer 5413 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 5414 
    result.write(oprot)
5415 
    oprot.writeMessageEnd()
5416 
    oprot.trans.flush()
5417 
 
4999 phani.kuma 5418 
  def process_getOrderList(self, seqid, iprot, oprot):
5419 
    args = getOrderList_args()
5420 
    args.read(iprot)
5421 
    iprot.readMessageEnd()
5422 
    result = getOrderList_result()
5423 
    result.success = self._handler.getOrderList(args.order_ids)
5424 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
5425 
    result.write(oprot)
5426 
    oprot.writeMessageEnd()
5427 
    oprot.trans.flush()
5428 
 
1528 ankur.sing 5429 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
5430 
    args = getOrderForCustomer_args()
5431 
    args.read(iprot)
5432 
    iprot.readMessageEnd()
5433 
    result = getOrderForCustomer_result()
5434 
    try:
5435 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
5436 
    except TransactionServiceException, ex:
5437 
      result.ex = ex
5438 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
5439 
    result.write(oprot)
5440 
    oprot.writeMessageEnd()
5441 
    oprot.trans.flush()
5442 
 
3064 chandransh 5443 
  def process_getAlerts(self, seqid, iprot, oprot):
5444 
    args = getAlerts_args()
5445 
    args.read(iprot)
5446 
    iprot.readMessageEnd()
5447 
    result = getAlerts_result()
4444 rajveer 5448 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 5449 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
5450 
    result.write(oprot)
5451 
    oprot.writeMessageEnd()
5452 
    oprot.trans.flush()
5453 
 
4394 rajveer 5454 
  def process_addAlert(self, seqid, iprot, oprot):
5455 
    args = addAlert_args()
3064 chandransh 5456 
    args.read(iprot)
5457 
    iprot.readMessageEnd()
4394 rajveer 5458 
    result = addAlert_result()
4444 rajveer 5459 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 5460 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 5461 
    result.write(oprot)
5462 
    oprot.writeMessageEnd()
5463 
    oprot.trans.flush()
5464 
 
4444 rajveer 5465 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
5466 
    args = markAlertsAsSeen_args()
5467 
    args.read(iprot)
5468 
    iprot.readMessageEnd()
5469 
    result = markAlertsAsSeen_result()
5470 
    self._handler.markAlertsAsSeen(args.warehouseId)
5471 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
5472 
    result.write(oprot)
5473 
    oprot.writeMessageEnd()
5474 
    oprot.trans.flush()
5475 
 
3064 chandransh 5476 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
5477 
    args = getValidOrderCount_args()
5478 
    args.read(iprot)
5479 
    iprot.readMessageEnd()
5480 
    result = getValidOrderCount_result()
5481 
    result.success = self._handler.getValidOrderCount()
5482 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
5483 
    result.write(oprot)
5484 
    oprot.writeMessageEnd()
5485 
    oprot.trans.flush()
5486 
 
5487 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
5488 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
5489 
    args.read(iprot)
5490 
    iprot.readMessageEnd()
5491 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
5492 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
5493 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
5494 
    result.write(oprot)
5495 
    oprot.writeMessageEnd()
5496 
    oprot.trans.flush()
5497 
 
5498 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
5499 
    args = getValidOrdersAmountRange_args()
5500 
    args.read(iprot)
5501 
    iprot.readMessageEnd()
5502 
    result = getValidOrdersAmountRange_result()
5503 
    result.success = self._handler.getValidOrdersAmountRange()
5504 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
5505 
    result.write(oprot)
5506 
    oprot.writeMessageEnd()
5507 
    oprot.trans.flush()
5508 
 
5509 
  def process_getValidOrders(self, seqid, iprot, oprot):
5510 
    args = getValidOrders_args()
5511 
    args.read(iprot)
5512 
    iprot.readMessageEnd()
5513 
    result = getValidOrders_result()
5514 
    result.success = self._handler.getValidOrders(args.limit)
5515 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
5516 
    result.write(oprot)
5517 
    oprot.writeMessageEnd()
5518 
    oprot.trans.flush()
5519 
 
1220 chandransh 5520 
  def process_batchOrders(self, seqid, iprot, oprot):
5521 
    args = batchOrders_args()
5522 
    args.read(iprot)
5523 
    iprot.readMessageEnd()
5524 
    result = batchOrders_result()
5525 
    try:
5526 
      result.success = self._handler.batchOrders(args.warehouseId)
5527 
    except TransactionServiceException, ex:
5528 
      result.ex = ex
5529 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
5530 
    result.write(oprot)
5531 
    oprot.writeMessageEnd()
5532 
    oprot.trans.flush()
5533 
 
1208 chandransh 5534 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
5535 
    args = markOrderAsOutOfStock_args()
5536 
    args.read(iprot)
5537 
    iprot.readMessageEnd()
5538 
    result = markOrderAsOutOfStock_result()
5539 
    try:
5540 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
5541 
    except TransactionServiceException, ex:
5542 
      result.ex = ex
5543 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
5544 
    result.write(oprot)
5545 
    oprot.writeMessageEnd()
5546 
    oprot.trans.flush()
5547 
 
3064 chandransh 5548 
  def process_verifyOrder(self, seqid, iprot, oprot):
5549 
    args = verifyOrder_args()
759 chandransh 5550 
    args.read(iprot)
5551 
    iprot.readMessageEnd()
3064 chandransh 5552 
    result = verifyOrder_result()
759 chandransh 5553 
    try:
3064 chandransh 5554 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 5555 
    except TransactionServiceException, ex:
5556 
      result.ex = ex
3064 chandransh 5557 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 5558 
    result.write(oprot)
5559 
    oprot.writeMessageEnd()
5560 
    oprot.trans.flush()
5561 
 
3064 chandransh 5562 
  def process_acceptOrder(self, seqid, iprot, oprot):
5563 
    args = acceptOrder_args()
1113 chandransh 5564 
    args.read(iprot)
5565 
    iprot.readMessageEnd()
3064 chandransh 5566 
    result = acceptOrder_result()
1113 chandransh 5567 
    try:
3064 chandransh 5568 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 5569 
    except TransactionServiceException, ex:
5570 
      result.ex = ex
3064 chandransh 5571 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 5572 
    result.write(oprot)
5573 
    oprot.writeMessageEnd()
5574 
    oprot.trans.flush()
5575 
 
3064 chandransh 5576 
  def process_addBillingDetails(self, seqid, iprot, oprot):
5577 
    args = addBillingDetails_args()
1135 chandransh 5578 
    args.read(iprot)
5579 
    iprot.readMessageEnd()
3064 chandransh 5580 
    result = addBillingDetails_result()
1135 chandransh 5581 
    try:
5110 mandeep.dh 5582 
      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 5583 
    except TransactionServiceException, ex:
5584 
      result.ex = ex
3064 chandransh 5585 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 5586 
    result.write(oprot)
5587 
    oprot.writeMessageEnd()
5588 
    oprot.trans.flush()
5589 
 
4579 rajveer 5590 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
5591 
    args = addInvoiceNumber_args()
5592 
    args.read(iprot)
5593 
    iprot.readMessageEnd()
5594 
    result = addInvoiceNumber_result()
5595 
    try:
4763 rajveer 5596 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 5597 
    except TransactionServiceException, ex:
5598 
      result.ex = ex
5599 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
5600 
    result.write(oprot)
5601 
    oprot.writeMessageEnd()
5602 
    oprot.trans.flush()
5603 
 
4410 rajveer 5604 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
5605 
    args = markOrdersAsShippedFromWarehouse_args()
5606 
    args.read(iprot)
5607 
    iprot.readMessageEnd()
5608 
    result = markOrdersAsShippedFromWarehouse_result()
5609 
    try:
4789 rajveer 5610 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 5611 
    except TransactionServiceException, ex:
5612 
      result.ex = ex
5613 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
5614 
    result.write(oprot)
5615 
    oprot.writeMessageEnd()
5616 
    oprot.trans.flush()
5617 
 
3064 chandransh 5618 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
5619 
    args = markOrdersAsPickedUp_args()
304 ashish 5620 
    args.read(iprot)
5621 
    iprot.readMessageEnd()
3064 chandransh 5622 
    result = markOrdersAsPickedUp_result()
5623 
    try:
4910 phani.kuma 5624 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 5625 
    except TransactionServiceException, ex:
5626 
      result.ex = ex
5627 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 5628 
    result.write(oprot)
5629 
    oprot.writeMessageEnd()
5630 
    oprot.trans.flush()
94 ashish 5631 
 
4910 phani.kuma 5632 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
5633 
    args = getOrdersNotPickedUp_args()
5634 
    args.read(iprot)
5635 
    iprot.readMessageEnd()
5636 
    result = getOrdersNotPickedUp_result()
5637 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
5638 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
5639 
    result.write(oprot)
5640 
    oprot.writeMessageEnd()
5641 
    oprot.trans.flush()
5642 
 
3064 chandransh 5643 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
5644 
    args = markOrdersAsDelivered_args()
304 ashish 5645 
    args.read(iprot)
5646 
    iprot.readMessageEnd()
3064 chandransh 5647 
    result = markOrdersAsDelivered_result()
5648 
    try:
5649 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
5650 
    except TransactionServiceException, ex:
5651 
      result.ex = ex
5652 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 5653 
    result.write(oprot)
5654 
    oprot.writeMessageEnd()
5655 
    oprot.trans.flush()
5656 
 
4910 phani.kuma 5657 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
5658 
    args = markAsRTOrders_args()
1596 ankur.sing 5659 
    args.read(iprot)
5660 
    iprot.readMessageEnd()
4910 phani.kuma 5661 
    result = markAsRTOrders_result()
3064 chandransh 5662 
    try:
4910 phani.kuma 5663 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 5664 
    except TransactionServiceException, ex:
5665 
      result.ex = ex
4910 phani.kuma 5666 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 5667 
    result.write(oprot)
5668 
    oprot.writeMessageEnd()
5669 
    oprot.trans.flush()
304 ashish 5670 
 
4910 phani.kuma 5671 
  def process_getRTOrders(self, seqid, iprot, oprot):
5672 
    args = getRTOrders_args()
5673 
    args.read(iprot)
5674 
    iprot.readMessageEnd()
5675 
    result = getRTOrders_result()
5676 
    result.success = self._handler.getRTOrders(args.providerId)
5677 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
5678 
    result.write(oprot)
5679 
    oprot.writeMessageEnd()
5680 
    oprot.trans.flush()
5681 
 
3064 chandransh 5682 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
5683 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 5684 
    args.read(iprot)
5685 
    iprot.readMessageEnd()
3064 chandransh 5686 
    result = updateNonDeliveryReason_result()
5687 
    try:
4910 phani.kuma 5688 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 5689 
    except TransactionServiceException, ex:
5690 
      result.ex = ex
5691 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 5692 
    result.write(oprot)
5693 
    oprot.writeMessageEnd()
5694 
    oprot.trans.flush()
1596 ankur.sing 5695 
 
4910 phani.kuma 5696 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
5697 
    args = getNonDeliveredOrdersbyCourier_args()
5698 
    args.read(iprot)
5699 
    iprot.readMessageEnd()
5700 
    result = getNonDeliveredOrdersbyCourier_result()
5701 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
5702 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
5703 
    result.write(oprot)
5704 
    oprot.writeMessageEnd()
5705 
    oprot.trans.flush()
5706 
 
5707 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
5708 
    args = markOrdersAsLocalConnected_args()
5709 
    args.read(iprot)
5710 
    iprot.readMessageEnd()
5711 
    result = markOrdersAsLocalConnected_result()
5712 
    try:
5713 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
5714 
    except TransactionServiceException, ex:
5715 
      result.ex = ex
5716 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
5717 
    result.write(oprot)
5718 
    oprot.writeMessageEnd()
5719 
    oprot.trans.flush()
5720 
 
5721 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
5722 
    args = getOrdersNotLocalConnected_args()
5723 
    args.read(iprot)
5724 
    iprot.readMessageEnd()
5725 
    result = getOrdersNotLocalConnected_result()
5726 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
5727 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
5728 
    result.write(oprot)
5729 
    oprot.writeMessageEnd()
5730 
    oprot.trans.flush()
5731 
 
5732 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
5733 
    args = markOrdersAsDestinationCityReached_args()
5734 
    args.read(iprot)
5735 
    iprot.readMessageEnd()
5736 
    result = markOrdersAsDestinationCityReached_result()
5737 
    try:
5738 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
5739 
    except TransactionServiceException, ex:
5740 
      result.ex = ex
5741 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
5742 
    result.write(oprot)
5743 
    oprot.writeMessageEnd()
5744 
    oprot.trans.flush()
5745 
 
5746 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
5747 
    args = markOrdersAsFirstDeliveryAttempted_args()
5748 
    args.read(iprot)
5749 
    iprot.readMessageEnd()
5750 
    result = markOrdersAsFirstDeliveryAttempted_result()
5751 
    try:
5752 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
5753 
    except TransactionServiceException, ex:
5754 
      result.ex = ex
5755 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
5756 
    result.write(oprot)
5757 
    oprot.writeMessageEnd()
5758 
    oprot.trans.flush()
5759 
 
3064 chandransh 5760 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
5761 
    args = getUndeliveredOrders_args()
1627 ankur.sing 5762 
    args.read(iprot)
5763 
    iprot.readMessageEnd()
3064 chandransh 5764 
    result = getUndeliveredOrders_result()
5765 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
5766 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 5767 
    result.write(oprot)
5768 
    oprot.writeMessageEnd()
5769 
    oprot.trans.flush()
5770 
 
4783 phani.kuma 5771 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
5772 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
5773 
    args.read(iprot)
5774 
    iprot.readMessageEnd()
5775 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
5776 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
5777 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
5778 
    result.write(oprot)
5779 
    oprot.writeMessageEnd()
5780 
    oprot.trans.flush()
5781 
 
2536 chandransh 5782 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
5783 
    args = toggleDOAFlag_args()
5784 
    args.read(iprot)
5785 
    iprot.readMessageEnd()
5786 
    result = toggleDOAFlag_result()
5787 
    try:
5788 
      result.success = self._handler.toggleDOAFlag(args.orderId)
5789 
    except TransactionServiceException, ex:
5790 
      result.ex = ex
5791 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
5792 
    result.write(oprot)
5793 
    oprot.writeMessageEnd()
5794 
    oprot.trans.flush()
1886 ankur.sing 5795 
 
4712 rajveer 5796 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
5797 
    args = markOrderAsDelivered_args()
5798 
    args.read(iprot)
5799 
    iprot.readMessageEnd()
5800 
    result = markOrderAsDelivered_result()
5801 
    try:
5802 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
5803 
    except TransactionServiceException, ex:
5804 
      result.ex = ex
5805 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
5806 
    result.write(oprot)
5807 
    oprot.writeMessageEnd()
5808 
    oprot.trans.flush()
5809 
 
4454 rajveer 5810 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
5811 
    args = markOrderDoaRequestReceived_args()
5812 
    args.read(iprot)
5813 
    iprot.readMessageEnd()
5814 
    result = markOrderDoaRequestReceived_result()
5815 
    try:
5816 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
5817 
    except TransactionServiceException, ex:
5818 
      result.ex = ex
5819 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
5820 
    result.write(oprot)
5821 
    oprot.writeMessageEnd()
5822 
    oprot.trans.flush()
5823 
 
5824 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
5825 
    args = markOrderDoaRequestAuthorized_args()
5826 
    args.read(iprot)
5827 
    iprot.readMessageEnd()
5828 
    result = markOrderDoaRequestAuthorized_result()
5829 
    try:
5830 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
5831 
    except TransactionServiceException, ex:
5832 
      result.ex = ex
5833 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
5834 
    result.write(oprot)
5835 
    oprot.writeMessageEnd()
5836 
    oprot.trans.flush()
5837 
 
4488 rajveer 5838 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
5839 
    args = markOrderReturnRequestReceived_args()
5840 
    args.read(iprot)
5841 
    iprot.readMessageEnd()
5842 
    result = markOrderReturnRequestReceived_result()
5843 
    try:
5844 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
5845 
    except TransactionServiceException, ex:
5846 
      result.ex = ex
5847 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
5848 
    result.write(oprot)
5849 
    oprot.writeMessageEnd()
5850 
    oprot.trans.flush()
5851 
 
5852 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
5853 
    args = markOrderReturnRequestAuthorized_args()
5854 
    args.read(iprot)
5855 
    iprot.readMessageEnd()
5856 
    result = markOrderReturnRequestAuthorized_result()
5857 
    try:
5858 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
5859 
    except TransactionServiceException, ex:
5860 
      result.ex = ex
5861 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
5862 
    result.write(oprot)
5863 
    oprot.writeMessageEnd()
5864 
    oprot.trans.flush()
5865 
 
2536 chandransh 5866 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
5867 
    args = requestPickupNumber_args()
5868 
    args.read(iprot)
5869 
    iprot.readMessageEnd()
5870 
    result = requestPickupNumber_result()
5871 
    try:
4579 rajveer 5872 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 5873 
    except TransactionServiceException, ex:
5874 
      result.ex = ex
5875 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
5876 
    result.write(oprot)
5877 
    oprot.writeMessageEnd()
5878 
    oprot.trans.flush()
5879 
 
5880 
  def process_authorizePickup(self, seqid, iprot, oprot):
5881 
    args = authorizePickup_args()
5882 
    args.read(iprot)
5883 
    iprot.readMessageEnd()
5884 
    result = authorizePickup_result()
5885 
    try:
4602 rajveer 5886 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 5887 
    except TransactionServiceException, ex:
5888 
      result.ex = ex
5889 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
5890 
    result.write(oprot)
5891 
    oprot.writeMessageEnd()
5892 
    oprot.trans.flush()
5893 
 
2764 chandransh 5894 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
5895 
    args = markDoasAsPickedUp_args()
5896 
    args.read(iprot)
5897 
    iprot.readMessageEnd()
5898 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 5899 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 5900 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
5901 
    result.write(oprot)
5902 
    oprot.writeMessageEnd()
5903 
    oprot.trans.flush()
5904 
 
4910 phani.kuma 5905 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
5906 
    args = getDoasNotPickedUp_args()
5907 
    args.read(iprot)
5908 
    iprot.readMessageEnd()
5909 
    result = getDoasNotPickedUp_result()
5910 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
5911 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
5912 
    result.write(oprot)
5913 
    oprot.writeMessageEnd()
5914 
    oprot.trans.flush()
5915 
 
4741 phani.kuma 5916 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
5917 
    args = markReturnOrdersAsPickedUp_args()
5918 
    args.read(iprot)
5919 
    iprot.readMessageEnd()
5920 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 5921 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 5922 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
5923 
    result.write(oprot)
5924 
    oprot.writeMessageEnd()
5925 
    oprot.trans.flush()
5926 
 
4910 phani.kuma 5927 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
5928 
    args = getReturnOrdersNotPickedUp_args()
5929 
    args.read(iprot)
5930 
    iprot.readMessageEnd()
5931 
    result = getReturnOrdersNotPickedUp_result()
5932 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
5933 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
5934 
    result.write(oprot)
5935 
    oprot.writeMessageEnd()
5936 
    oprot.trans.flush()
5937 
 
2616 chandransh 5938 
  def process_receiveReturn(self, seqid, iprot, oprot):
5939 
    args = receiveReturn_args()
2591 chandransh 5940 
    args.read(iprot)
5941 
    iprot.readMessageEnd()
2616 chandransh 5942 
    result = receiveReturn_result()
2591 chandransh 5943 
    try:
4479 rajveer 5944 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 5945 
    except TransactionServiceException, ex:
5946 
      result.ex = ex
2616 chandransh 5947 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 5948 
    result.write(oprot)
5949 
    oprot.writeMessageEnd()
5950 
    oprot.trans.flush()
2536 chandransh 5951 
 
2591 chandransh 5952 
  def process_validateDoa(self, seqid, iprot, oprot):
5953 
    args = validateDoa_args()
5954 
    args.read(iprot)
5955 
    iprot.readMessageEnd()
5956 
    result = validateDoa_result()
5957 
    try:
5958 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
5959 
    except TransactionServiceException, ex:
5960 
      result.ex = ex
5961 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
5962 
    result.write(oprot)
5963 
    oprot.writeMessageEnd()
5964 
    oprot.trans.flush()
5965 
 
4495 rajveer 5966 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
5967 
    args = validateReturnProduct_args()
5968 
    args.read(iprot)
5969 
    iprot.readMessageEnd()
5970 
    result = validateReturnProduct_result()
5971 
    try:
5972 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
5973 
    except TransactionServiceException, ex:
5974 
      result.ex = ex
5975 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
5976 
    result.write(oprot)
5977 
    oprot.writeMessageEnd()
5978 
    oprot.trans.flush()
5979 
 
2616 chandransh 5980 
  def process_reshipOrder(self, seqid, iprot, oprot):
5981 
    args = reshipOrder_args()
5982 
    args.read(iprot)
5983 
    iprot.readMessageEnd()
5984 
    result = reshipOrder_result()
5985 
    try:
5986 
      result.success = self._handler.reshipOrder(args.orderId)
5987 
    except TransactionServiceException, ex:
5988 
      result.ex = ex
5989 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
5990 
    result.write(oprot)
5991 
    oprot.writeMessageEnd()
5992 
    oprot.trans.flush()
2591 chandransh 5993 
 
2616 chandransh 5994 
  def process_refundOrder(self, seqid, iprot, oprot):
5995 
    args = refundOrder_args()
5996 
    args.read(iprot)
5997 
    iprot.readMessageEnd()
5998 
    result = refundOrder_result()
5999 
    try:
3226 chandransh 6000 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 6001 
    except TransactionServiceException, ex:
6002 
      result.ex = ex
6003 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
6004 
    result.write(oprot)
6005 
    oprot.writeMessageEnd()
6006 
    oprot.trans.flush()
6007 
 
2690 chandransh 6008 
  def process_getReturnOrders(self, seqid, iprot, oprot):
6009 
    args = getReturnOrders_args()
6010 
    args.read(iprot)
6011 
    iprot.readMessageEnd()
6012 
    result = getReturnOrders_result()
6013 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
6014 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
6015 
    result.write(oprot)
6016 
    oprot.writeMessageEnd()
6017 
    oprot.trans.flush()
2616 chandransh 6018 
 
2700 chandransh 6019 
  def process_getReturnOrder(self, seqid, iprot, oprot):
6020 
    args = getReturnOrder_args()
6021 
    args.read(iprot)
6022 
    iprot.readMessageEnd()
6023 
    result = getReturnOrder_result()
6024 
    try:
6025 
      result.success = self._handler.getReturnOrder(args.id)
6026 
    except TransactionServiceException, ex:
6027 
      result.ex = ex
6028 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
6029 
    result.write(oprot)
6030 
    oprot.writeMessageEnd()
6031 
    oprot.trans.flush()
6032 
 
2690 chandransh 6033 
  def process_processReturn(self, seqid, iprot, oprot):
6034 
    args = processReturn_args()
6035 
    args.read(iprot)
6036 
    iprot.readMessageEnd()
6037 
    result = processReturn_result()
6038 
    try:
6039 
      self._handler.processReturn(args.returnOrderId)
6040 
    except TransactionServiceException, ex:
6041 
      result.ex = ex
6042 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
6043 
    result.write(oprot)
6044 
    oprot.writeMessageEnd()
6045 
    oprot.trans.flush()
6046 
 
3451 chandransh 6047 
  def process_updateWeight(self, seqid, iprot, oprot):
6048 
    args = updateWeight_args()
6049 
    args.read(iprot)
6050 
    iprot.readMessageEnd()
6051 
    result = updateWeight_result()
6052 
    try:
6053 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
6054 
    except TransactionServiceException, ex:
6055 
      result.ex = ex
6056 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
6057 
    result.write(oprot)
6058 
    oprot.writeMessageEnd()
6059 
    oprot.trans.flush()
2819 chandransh 6060 
 
3469 chandransh 6061 
  def process_changeItem(self, seqid, iprot, oprot):
6062 
    args = changeItem_args()
6063 
    args.read(iprot)
6064 
    iprot.readMessageEnd()
6065 
    result = changeItem_result()
6066 
    try:
6067 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
6068 
    except TransactionServiceException, ex:
6069 
      result.ex = ex
6070 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
6071 
    result.write(oprot)
6072 
    oprot.writeMessageEnd()
6073 
    oprot.trans.flush()
3451 chandransh 6074 
 
3469 chandransh 6075 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
6076 
    args = shiftToWarehouse_args()
6077 
    args.read(iprot)
6078 
    iprot.readMessageEnd()
6079 
    result = shiftToWarehouse_result()
6080 
    try:
6081 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
6082 
    except TransactionServiceException, ex:
6083 
      result.ex = ex
6084 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
6085 
    result.write(oprot)
6086 
    oprot.writeMessageEnd()
6087 
    oprot.trans.flush()
6088 
 
3553 chandransh 6089 
  def process_addDelayReason(self, seqid, iprot, oprot):
6090 
    args = addDelayReason_args()
6091 
    args.read(iprot)
6092 
    iprot.readMessageEnd()
6093 
    result = addDelayReason_result()
6094 
    try:
4647 rajveer 6095 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 6096 
    except TransactionServiceException, ex:
6097 
      result.ex = ex
6098 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
6099 
    result.write(oprot)
6100 
    oprot.writeMessageEnd()
6101 
    oprot.trans.flush()
3469 chandransh 6102 
 
3956 chandransh 6103 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
6104 
    args = reconcileCodCollection_args()
6105 
    args.read(iprot)
6106 
    iprot.readMessageEnd()
6107 
    result = reconcileCodCollection_result()
6108 
    try:
6109 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
6110 
    except TransactionServiceException, ex:
6111 
      result.ex = ex
6112 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
6113 
    result.write(oprot)
6114 
    oprot.writeMessageEnd()
6115 
    oprot.trans.flush()
3553 chandransh 6116 
 
4008 mandeep.dh 6117 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
6118 
    args = getTransactionsRequiringExtraProcessing_args()
6119 
    args.read(iprot)
6120 
    iprot.readMessageEnd()
6121 
    result = getTransactionsRequiringExtraProcessing_result()
6122 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
6123 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
6124 
    result.write(oprot)
6125 
    oprot.writeMessageEnd()
6126 
    oprot.trans.flush()
3956 chandransh 6127 
 
4008 mandeep.dh 6128 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
6129 
    args = markTransactionAsProcessed_args()
6130 
    args.read(iprot)
6131 
    iprot.readMessageEnd()
6132 
    result = markTransactionAsProcessed_result()
6133 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
6134 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
6135 
    result.write(oprot)
6136 
    oprot.writeMessageEnd()
6137 
    oprot.trans.flush()
6138 
 
4018 chandransh 6139 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
6140 
    args = getItemWiseRiskyOrdersCount_args()
6141 
    args.read(iprot)
6142 
    iprot.readMessageEnd()
6143 
    result = getItemWiseRiskyOrdersCount_result()
6144 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
6145 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
6146 
    result.write(oprot)
6147 
    oprot.writeMessageEnd()
6148 
    oprot.trans.flush()
4008 mandeep.dh 6149 
 
4295 varun.gupt 6150 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
6151 
    args = getOrdersForItemIds_args()
6152 
    args.read(iprot)
6153 
    iprot.readMessageEnd()
6154 
    result = getOrdersForItemIds_result()
6155 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
6156 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
6157 
    result.write(oprot)
6158 
    oprot.writeMessageEnd()
6159 
    oprot.trans.flush()
6160 
 
4247 rajveer 6161 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
6162 
    args = markOrderCancellationRequestReceived_args()
6163 
    args.read(iprot)
6164 
    iprot.readMessageEnd()
6165 
    result = markOrderCancellationRequestReceived_result()
6166 
    try:
6167 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
6168 
    except TransactionServiceException, ex:
6169 
      result.ex = ex
6170 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
6171 
    result.write(oprot)
6172 
    oprot.writeMessageEnd()
6173 
    oprot.trans.flush()
4018 chandransh 6174 
 
4247 rajveer 6175 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
6176 
    args = markOrderCancellationRequestConfirmed_args()
6177 
    args.read(iprot)
6178 
    iprot.readMessageEnd()
6179 
    result = markOrderCancellationRequestConfirmed_result()
6180 
    try:
6181 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
6182 
    except TransactionServiceException, ex:
6183 
      result.ex = ex
6184 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
6185 
    result.write(oprot)
6186 
    oprot.writeMessageEnd()
6187 
    oprot.trans.flush()
6188 
 
6189 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
6190 
    args = markOrderCancellationRequestDenied_args()
6191 
    args.read(iprot)
6192 
    iprot.readMessageEnd()
6193 
    result = markOrderCancellationRequestDenied_result()
6194 
    try:
6195 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
6196 
    except TransactionServiceException, ex:
6197 
      result.ex = ex
6198 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
6199 
    result.write(oprot)
6200 
    oprot.writeMessageEnd()
6201 
    oprot.trans.flush()
6202 
 
4258 rajveer 6203 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
6204 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 6205 
    args.read(iprot)
6206 
    iprot.readMessageEnd()
4258 rajveer 6207 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 6208 
    try:
4258 rajveer 6209 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 6210 
    except TransactionServiceException, ex:
6211 
      result.ex = ex
4258 rajveer 6212 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 6213 
    result.write(oprot)
6214 
    oprot.writeMessageEnd()
6215 
    oprot.trans.flush()
6216 
 
4259 anupam.sin 6217 
  def process_refundTransaction(self, seqid, iprot, oprot):
6218 
    args = refundTransaction_args()
6219 
    args.read(iprot)
6220 
    iprot.readMessageEnd()
6221 
    result = refundTransaction_result()
6222 
    try:
6223 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
6224 
    except TransactionServiceException, ex:
6225 
      result.ex = ex
6226 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
6227 
    result.write(oprot)
6228 
    oprot.writeMessageEnd()
6229 
    oprot.trans.flush()
4247 rajveer 6230 
 
4324 mandeep.dh 6231 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
6232 
    args = updateShipmentAddress_args()
6233 
    args.read(iprot)
6234 
    iprot.readMessageEnd()
6235 
    result = updateShipmentAddress_result()
6236 
    try:
6237 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
6238 
    except TransactionServiceException, ex:
6239 
      result.ex = ex
6240 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
6241 
    result.write(oprot)
6242 
    oprot.writeMessageEnd()
6243 
    oprot.trans.flush()
6244 
 
4285 rajveer 6245 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
6246 
    args = acceptOrdersForItemId_args()
6247 
    args.read(iprot)
6248 
    iprot.readMessageEnd()
6249 
    result = acceptOrdersForItemId_result()
6250 
    try:
6251 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
6252 
    except TransactionServiceException, ex:
6253 
      result.ex = ex
6254 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
6255 
    result.write(oprot)
6256 
    oprot.writeMessageEnd()
6257 
    oprot.trans.flush()
4259 anupam.sin 6258 
 
4303 rajveer 6259 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
6260 
    args = markOrdersAsPORaised_args()
6261 
    args.read(iprot)
6262 
    iprot.readMessageEnd()
6263 
    result = markOrdersAsPORaised_result()
6264 
    try:
4369 rajveer 6265 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6266 
    except TransactionServiceException, ex:
6267 
      result.ex = ex
6268 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
6269 
    result.write(oprot)
6270 
    oprot.writeMessageEnd()
6271 
    oprot.trans.flush()
4285 rajveer 6272 
 
4303 rajveer 6273 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
6274 
    args = markOrdersAsReversalInitiated_args()
6275 
    args.read(iprot)
6276 
    iprot.readMessageEnd()
6277 
    result = markOrdersAsReversalInitiated_result()
6278 
    try:
4369 rajveer 6279 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6280 
    except TransactionServiceException, ex:
6281 
      result.ex = ex
6282 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
6283 
    result.write(oprot)
6284 
    oprot.writeMessageEnd()
6285 
    oprot.trans.flush()
6286 
 
6287 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
6288 
    args = markOrdersAsNotAvailabke_args()
6289 
    args.read(iprot)
6290 
    iprot.readMessageEnd()
6291 
    result = markOrdersAsNotAvailabke_result()
6292 
    try:
4369 rajveer 6293 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6294 
    except TransactionServiceException, ex:
6295 
      result.ex = ex
6296 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
6297 
    result.write(oprot)
6298 
    oprot.writeMessageEnd()
6299 
    oprot.trans.flush()
6300 
 
4369 rajveer 6301 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
6302 
    args = markOrdersAsTimeout_args()
6303 
    args.read(iprot)
6304 
    iprot.readMessageEnd()
6305 
    result = markOrdersAsTimeout_result()
6306 
    try:
6307 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
6308 
    except TransactionServiceException, ex:
6309 
      result.ex = ex
6310 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
6311 
    result.write(oprot)
6312 
    oprot.writeMessageEnd()
6313 
    oprot.trans.flush()
4303 rajveer 6314 
 
4662 rajveer 6315 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
6316 
    args = markOrderAsLostInTransit_args()
6317 
    args.read(iprot)
6318 
    iprot.readMessageEnd()
6319 
    result = markOrderAsLostInTransit_result()
6320 
    try:
6321 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
6322 
    except TransactionServiceException, ex:
6323 
      result.ex = ex
6324 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
6325 
    result.write(oprot)
6326 
    oprot.writeMessageEnd()
6327 
    oprot.trans.flush()
6328 
 
4386 anupam.sin 6329 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
6330 
    args = getOrderForAwb_args()
6331 
    args.read(iprot)
6332 
    iprot.readMessageEnd()
6333 
    result = getOrderForAwb_result()
6334 
    try:
6335 
      result.success = self._handler.getOrderForAwb(args.awb)
6336 
    except TransactionServiceException, ex:
6337 
      result.ex = ex
6338 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
6339 
    result.write(oprot)
6340 
    oprot.writeMessageEnd()
6341 
    oprot.trans.flush()
4369 rajveer 6342 
 
4506 phani.kuma 6343 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
6344 
    args = getOrdersForProviderForStatus_args()
6345 
    args.read(iprot)
6346 
    iprot.readMessageEnd()
6347 
    result = getOrdersForProviderForStatus_result()
6348 
    try:
4910 phani.kuma 6349 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 6350 
    except TransactionServiceException, ex:
6351 
      result.ex = ex
6352 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
6353 
    result.write(oprot)
6354 
    oprot.writeMessageEnd()
6355 
    oprot.trans.flush()
4386 anupam.sin 6356 
 
4600 varun.gupt 6357 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
6358 
    args = getBilledOrdersForVendor_args()
6359 
    args.read(iprot)
6360 
    iprot.readMessageEnd()
6361 
    result = getBilledOrdersForVendor_result()
6362 
    try:
6363 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
6364 
    except TransactionServiceException, ex:
6365 
      result.ex = ex
6366 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
6367 
    result.write(oprot)
6368 
    oprot.writeMessageEnd()
6369 
    oprot.trans.flush()
4506 phani.kuma 6370 
 
4607 rajveer 6371 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
6372 
    args = getSlippedSippingDateOrders_args()
6373 
    args.read(iprot)
6374 
    iprot.readMessageEnd()
6375 
    result = getSlippedSippingDateOrders_result()
6376 
    try:
6377 
      result.success = self._handler.getSlippedSippingDateOrders()
6378 
    except TransactionServiceException, ex:
6379 
      result.ex = ex
6380 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
6381 
    result.write(oprot)
6382 
    oprot.writeMessageEnd()
6383 
    oprot.trans.flush()
6384 
 
4709 rajveer 6385 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
6386 
    args = getCancelledOrders_args()
6387 
    args.read(iprot)
6388 
    iprot.readMessageEnd()
6389 
    result = getCancelledOrders_result()
6390 
    try:
6391 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
6392 
    except TransactionServiceException, ex:
6393 
      result.ex = ex
6394 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
6395 
    result.write(oprot)
6396 
    oprot.writeMessageEnd()
6397 
    oprot.trans.flush()
6398 
 
4600 varun.gupt 6399 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
6400 
    args = saveBluedartSettlements_args()
6401 
    args.read(iprot)
6402 
    iprot.readMessageEnd()
6403 
    result = saveBluedartSettlements_result()
6404 
    try:
6405 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
6406 
    except TransactionServiceException, ex:
6407 
      result.ex = ex
6408 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
6409 
    result.write(oprot)
6410 
    oprot.writeMessageEnd()
6411 
    oprot.trans.flush()
6412 
 
6413 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
6414 
    args = savePaymentSettlements_args()
6415 
    args.read(iprot)
6416 
    iprot.readMessageEnd()
6417 
    result = savePaymentSettlements_result()
6418 
    try:
4905 varun.gupt 6419 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 6420 
    except TransactionServiceException, ex:
6421 
      result.ex = ex
6422 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
6423 
    result.write(oprot)
6424 
    oprot.writeMessageEnd()
6425 
    oprot.trans.flush()
6426 
 
6427 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
6428 
    args = saveEBSSettlementSummary_args()
6429 
    args.read(iprot)
6430 
    iprot.readMessageEnd()
6431 
    result = saveEBSSettlementSummary_result()
6432 
    try:
6433 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
6434 
    except TransactionServiceException, ex:
6435 
      result.ex = ex
6436 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
6437 
    result.write(oprot)
6438 
    oprot.writeMessageEnd()
6439 
    oprot.trans.flush()
6440 
 
5189 varun.gupt 6441 
  def process_getSettlementForReferenceId(self, seqid, iprot, oprot):
6442 
    args = getSettlementForReferenceId_args()
4600 varun.gupt 6443 
    args.read(iprot)
6444 
    iprot.readMessageEnd()
5189 varun.gupt 6445 
    result = getSettlementForReferenceId_result()
4600 varun.gupt 6446 
    try:
5189 varun.gupt 6447 
      result.success = self._handler.getSettlementForReferenceId(args.referenceId, args.isRefund)
4600 varun.gupt 6448 
    except TransactionServiceException, ex:
6449 
      result.ex = ex
5189 varun.gupt 6450 
    oprot.writeMessageBegin("getSettlementForReferenceId", TMessageType.REPLY, seqid)
4600 varun.gupt 6451 
    result.write(oprot)
6452 
    oprot.writeMessageEnd()
6453 
    oprot.trans.flush()
6454 
 
6455 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
6456 
    args = getEBSSettlementSummaries_args()
6457 
    args.read(iprot)
6458 
    iprot.readMessageEnd()
6459 
    result = getEBSSettlementSummaries_result()
6460 
    try:
6461 
      result.success = self._handler.getEBSSettlementSummaries()
6462 
    except TransactionServiceException, ex:
6463 
      result.ex = ex
6464 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
6465 
    result.write(oprot)
6466 
    oprot.writeMessageEnd()
6467 
    oprot.trans.flush()
6468 
 
6469 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
6470 
    args = markEBSSettlementUploaded_args()
6471 
    args.read(iprot)
6472 
    iprot.readMessageEnd()
6473 
    result = markEBSSettlementUploaded_result()
6474 
    try:
6475 
      self._handler.markEBSSettlementUploaded(args.settlementId)
6476 
    except TransactionServiceException, ex:
6477 
      result.ex = ex
6478 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
6479 
    result.write(oprot)
6480 
    oprot.writeMessageEnd()
6481 
    oprot.trans.flush()
6482 
 
6483 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
6484 
    args = getEBSSettlementDate_args()
6485 
    args.read(iprot)
6486 
    iprot.readMessageEnd()
6487 
    result = getEBSSettlementDate_result()
6488 
    try:
6489 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
6490 
    except TransactionServiceException, ex:
6491 
      result.ex = ex
6492 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
6493 
    result.write(oprot)
6494 
    oprot.writeMessageEnd()
6495 
    oprot.trans.flush()
6496 
 
4715 varun.gupt 6497 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
6498 
    args = getSettlementsByDate_args()
6499 
    args.read(iprot)
6500 
    iprot.readMessageEnd()
6501 
    result = getSettlementsByDate_result()
6502 
    try:
6503 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
6504 
    except TransactionServiceException, ex:
6505 
      result.ex = ex
6506 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
6507 
    result.write(oprot)
6508 
    oprot.writeMessageEnd()
6509 
    oprot.trans.flush()
4600 varun.gupt 6510 
 
4715 varun.gupt 6511 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
6512 
    args = getReshippedOrderIds_args()
6513 
    args.read(iprot)
6514 
    iprot.readMessageEnd()
6515 
    result = getReshippedOrderIds_result()
6516 
    try:
6517 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
6518 
    except TransactionServiceException, ex:
6519 
      result.ex = ex
6520 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
6521 
    result.write(oprot)
6522 
    oprot.writeMessageEnd()
6523 
    oprot.trans.flush()
6524 
 
4757 mandeep.dh 6525 
  def process_updateOrdersAsPORaised(self, seqid, iprot, oprot):
6526 
    args = updateOrdersAsPORaised_args()
6527 
    args.read(iprot)
6528 
    iprot.readMessageEnd()
6529 
    result = updateOrdersAsPORaised_result()
6530 
    try:
6531 
      self._handler.updateOrdersAsPORaised(args.itemIdQuantityMap, args.purchaseOrderId, args.warehouseId)
6532 
    except TransactionServiceException, ex:
6533 
      result.ex = ex
6534 
    oprot.writeMessageBegin("updateOrdersAsPORaised", TMessageType.REPLY, seqid)
6535 
    result.write(oprot)
6536 
    oprot.writeMessageEnd()
6537 
    oprot.trans.flush()
4715 varun.gupt 6538 
 
4875 varun.gupt 6539 
  def process_getOrdersWhereVendorNotPaid(self, seqid, iprot, oprot):
6540 
    args = getOrdersWhereVendorNotPaid_args()
6541 
    args.read(iprot)
6542 
    iprot.readMessageEnd()
6543 
    result = getOrdersWhereVendorNotPaid_result()
6544 
    try:
6545 
      result.success = self._handler.getOrdersWhereVendorNotPaid(args.vendorId)
6546 
    except TransactionServiceException, ex:
6547 
      result.ex = ex
6548 
    oprot.writeMessageBegin("getOrdersWhereVendorNotPaid", TMessageType.REPLY, seqid)
6549 
    result.write(oprot)
6550 
    oprot.writeMessageEnd()
6551 
    oprot.trans.flush()
4757 mandeep.dh 6552 
 
5031 varun.gupt 6553 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
6554 
    args = getStatusDistributionOfOrders_args()
6555 
    args.read(iprot)
6556 
    iprot.readMessageEnd()
6557 
    result = getStatusDistributionOfOrders_result()
6558 
    try:
6559 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
6560 
    except TransactionServiceException, ex:
6561 
      result.ex = ex
6562 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
6563 
    result.write(oprot)
6564 
    oprot.writeMessageEnd()
6565 
    oprot.trans.flush()
4875 varun.gupt 6566 
 
5067 varun.gupt 6567 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
6568 
    args = getOrderIdsForStatus_args()
6569 
    args.read(iprot)
6570 
    iprot.readMessageEnd()
6571 
    result = getOrderIdsForStatus_result()
6572 
    try:
6573 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
6574 
    except TransactionServiceException, ex:
6575 
      result.ex = ex
6576 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
6577 
    result.write(oprot)
6578 
    oprot.writeMessageEnd()
6579 
    oprot.trans.flush()
5031 varun.gupt 6580 
 
5099 varun.gupt 6581 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
6582 
    args = updateOrderAsPaidToVendor_args()
6583 
    args.read(iprot)
6584 
    iprot.readMessageEnd()
6585 
    result = updateOrderAsPaidToVendor_result()
6586 
    try:
6587 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
6588 
    except TransactionServiceException, ex:
6589 
      result.ex = ex
6590 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
6591 
    result.write(oprot)
6592 
    oprot.writeMessageEnd()
6593 
    oprot.trans.flush()
5067 varun.gupt 6594 
 
5208 varun.gupt 6595 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
6596 
    args = getRefundedOrdersMarkedPaid_args()
6597 
    args.read(iprot)
6598 
    iprot.readMessageEnd()
6599 
    result = getRefundedOrdersMarkedPaid_result()
6600 
    try:
6601 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
6602 
    except TransactionServiceException, ex:
6603 
      result.ex = ex
6604 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
6605 
    result.write(oprot)
6606 
    oprot.writeMessageEnd()
6607 
    oprot.trans.flush()
5099 varun.gupt 6608 
 
5208 varun.gupt 6609 
 
94 ashish 6610 
# HELPER FUNCTIONS AND STRUCTURES
6611 
 
6612 
class createTransaction_args:
6613 
  """
6614 
  Attributes:
6615 
   - transaction
6616 
  """
6617 
 
6618 
  thrift_spec = (
6619 
    None, # 0
6620 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
6621 
  )
6622 
 
6623 
  def __init__(self, transaction=None,):
6624 
    self.transaction = transaction
6625 
 
6626 
  def read(self, iprot):
6627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6629 
      return
6630 
    iprot.readStructBegin()
6631 
    while True:
6632 
      (fname, ftype, fid) = iprot.readFieldBegin()
6633 
      if ftype == TType.STOP:
6634 
        break
6635 
      if fid == 1:
6636 
        if ftype == TType.STRUCT:
6637 
          self.transaction = Transaction()
6638 
          self.transaction.read(iprot)
6639 
        else:
6640 
          iprot.skip(ftype)
6641 
      else:
6642 
        iprot.skip(ftype)
6643 
      iprot.readFieldEnd()
6644 
    iprot.readStructEnd()
6645 
 
6646 
  def write(self, oprot):
6647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6649 
      return
6650 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 6651 
    if self.transaction is not None:
94 ashish 6652 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
6653 
      self.transaction.write(oprot)
6654 
      oprot.writeFieldEnd()
6655 
    oprot.writeFieldStop()
6656 
    oprot.writeStructEnd()
6657 
 
3431 rajveer 6658 
  def validate(self):
6659 
    return
6660 
 
6661 
 
94 ashish 6662 
  def __repr__(self):
6663 
    L = ['%s=%r' % (key, value)
6664 
      for key, value in self.__dict__.iteritems()]
6665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6666 
 
6667 
  def __eq__(self, other):
6668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6669 
 
6670 
  def __ne__(self, other):
6671 
    return not (self == other)
6672 
 
6673 
class createTransaction_result:
6674 
  """
6675 
  Attributes:
132 ashish 6676 
   - success
94 ashish 6677 
   - ex
6678 
  """
6679 
 
6680 
  thrift_spec = (
132 ashish 6681 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 6682 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6683 
  )
6684 
 
132 ashish 6685 
  def __init__(self, success=None, ex=None,):
6686 
    self.success = success
94 ashish 6687 
    self.ex = ex
6688 
 
6689 
  def read(self, iprot):
6690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6692 
      return
6693 
    iprot.readStructBegin()
6694 
    while True:
6695 
      (fname, ftype, fid) = iprot.readFieldBegin()
6696 
      if ftype == TType.STOP:
6697 
        break
132 ashish 6698 
      if fid == 0:
6699 
        if ftype == TType.I64:
6700 
          self.success = iprot.readI64();
6701 
        else:
6702 
          iprot.skip(ftype)
6703 
      elif fid == 1:
94 ashish 6704 
        if ftype == TType.STRUCT:
6705 
          self.ex = TransactionServiceException()
6706 
          self.ex.read(iprot)
6707 
        else:
6708 
          iprot.skip(ftype)
6709 
      else:
6710 
        iprot.skip(ftype)
6711 
      iprot.readFieldEnd()
6712 
    iprot.readStructEnd()
6713 
 
6714 
  def write(self, oprot):
6715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6717 
      return
6718 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 6719 
    if self.success is not None:
132 ashish 6720 
      oprot.writeFieldBegin('success', TType.I64, 0)
6721 
      oprot.writeI64(self.success)
6722 
      oprot.writeFieldEnd()
3431 rajveer 6723 
    if self.ex is not None:
94 ashish 6724 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6725 
      self.ex.write(oprot)
6726 
      oprot.writeFieldEnd()
6727 
    oprot.writeFieldStop()
6728 
    oprot.writeStructEnd()
6729 
 
3431 rajveer 6730 
  def validate(self):
6731 
    return
6732 
 
6733 
 
94 ashish 6734 
  def __repr__(self):
6735 
    L = ['%s=%r' % (key, value)
6736 
      for key, value in self.__dict__.iteritems()]
6737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6738 
 
6739 
  def __eq__(self, other):
6740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6741 
 
6742 
  def __ne__(self, other):
6743 
    return not (self == other)
6744 
 
6745 
class getTransaction_args:
6746 
  """
6747 
  Attributes:
6748 
   - id
6749 
  """
6750 
 
6751 
  thrift_spec = (
6752 
    None, # 0
6753 
    (1, TType.I64, 'id', None, None, ), # 1
6754 
  )
6755 
 
6756 
  def __init__(self, id=None,):
6757 
    self.id = id
6758 
 
6759 
  def read(self, iprot):
6760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6762 
      return
6763 
    iprot.readStructBegin()
6764 
    while True:
6765 
      (fname, ftype, fid) = iprot.readFieldBegin()
6766 
      if ftype == TType.STOP:
6767 
        break
6768 
      if fid == 1:
6769 
        if ftype == TType.I64:
6770 
          self.id = iprot.readI64();
6771 
        else:
6772 
          iprot.skip(ftype)
6773 
      else:
6774 
        iprot.skip(ftype)
6775 
      iprot.readFieldEnd()
6776 
    iprot.readStructEnd()
6777 
 
6778 
  def write(self, oprot):
6779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6781 
      return
6782 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 6783 
    if self.id is not None:
94 ashish 6784 
      oprot.writeFieldBegin('id', TType.I64, 1)
6785 
      oprot.writeI64(self.id)
6786 
      oprot.writeFieldEnd()
6787 
    oprot.writeFieldStop()
6788 
    oprot.writeStructEnd()
6789 
 
3431 rajveer 6790 
  def validate(self):
6791 
    return
6792 
 
6793 
 
94 ashish 6794 
  def __repr__(self):
6795 
    L = ['%s=%r' % (key, value)
6796 
      for key, value in self.__dict__.iteritems()]
6797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6798 
 
6799 
  def __eq__(self, other):
6800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6801 
 
6802 
  def __ne__(self, other):
6803 
    return not (self == other)
6804 
 
6805 
class getTransaction_result:
6806 
  """
6807 
  Attributes:
6808 
   - success
6809 
   - ex
6810 
  """
6811 
 
6812 
  thrift_spec = (
6813 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
6814 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6815 
  )
6816 
 
6817 
  def __init__(self, success=None, ex=None,):
6818 
    self.success = success
6819 
    self.ex = ex
6820 
 
6821 
  def read(self, iprot):
6822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6824 
      return
6825 
    iprot.readStructBegin()
6826 
    while True:
6827 
      (fname, ftype, fid) = iprot.readFieldBegin()
6828 
      if ftype == TType.STOP:
6829 
        break
6830 
      if fid == 0:
6831 
        if ftype == TType.STRUCT:
6832 
          self.success = Transaction()
6833 
          self.success.read(iprot)
6834 
        else:
6835 
          iprot.skip(ftype)
6836 
      elif fid == 1:
6837 
        if ftype == TType.STRUCT:
6838 
          self.ex = TransactionServiceException()
6839 
          self.ex.read(iprot)
6840 
        else:
6841 
          iprot.skip(ftype)
6842 
      else:
6843 
        iprot.skip(ftype)
6844 
      iprot.readFieldEnd()
6845 
    iprot.readStructEnd()
6846 
 
6847 
  def write(self, oprot):
6848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6850 
      return
6851 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 6852 
    if self.success is not None:
94 ashish 6853 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6854 
      self.success.write(oprot)
6855 
      oprot.writeFieldEnd()
3431 rajveer 6856 
    if self.ex is not None:
94 ashish 6857 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6858 
      self.ex.write(oprot)
6859 
      oprot.writeFieldEnd()
6860 
    oprot.writeFieldStop()
6861 
    oprot.writeStructEnd()
6862 
 
3431 rajveer 6863 
  def validate(self):
6864 
    return
6865 
 
6866 
 
94 ashish 6867 
  def __repr__(self):
6868 
    L = ['%s=%r' % (key, value)
6869 
      for key, value in self.__dict__.iteritems()]
6870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6871 
 
6872 
  def __eq__(self, other):
6873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6874 
 
6875 
  def __ne__(self, other):
6876 
    return not (self == other)
6877 
 
6878 
class getTransactionsForCustomer_args:
6879 
  """
6880 
  Attributes:
6881 
   - customerId
6882 
   - from_date
6883 
   - to_date
6884 
   - status
6885 
  """
6886 
 
6887 
  thrift_spec = (
6888 
    None, # 0
6889 
    (1, TType.I64, 'customerId', None, None, ), # 1
6890 
    (2, TType.I64, 'from_date', None, None, ), # 2
6891 
    (3, TType.I64, 'to_date', None, None, ), # 3
6892 
    (4, TType.I32, 'status', None, None, ), # 4
6893 
  )
6894 
 
6895 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
6896 
    self.customerId = customerId
6897 
    self.from_date = from_date
6898 
    self.to_date = to_date
6899 
    self.status = status
6900 
 
6901 
  def read(self, iprot):
6902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6904 
      return
6905 
    iprot.readStructBegin()
6906 
    while True:
6907 
      (fname, ftype, fid) = iprot.readFieldBegin()
6908 
      if ftype == TType.STOP:
6909 
        break
6910 
      if fid == 1:
6911 
        if ftype == TType.I64:
6912 
          self.customerId = iprot.readI64();
6913 
        else:
6914 
          iprot.skip(ftype)
6915 
      elif fid == 2:
6916 
        if ftype == TType.I64:
6917 
          self.from_date = iprot.readI64();
6918 
        else:
6919 
          iprot.skip(ftype)
6920 
      elif fid == 3:
6921 
        if ftype == TType.I64:
6922 
          self.to_date = iprot.readI64();
6923 
        else:
6924 
          iprot.skip(ftype)
6925 
      elif fid == 4:
6926 
        if ftype == TType.I32:
6927 
          self.status = iprot.readI32();
6928 
        else:
6929 
          iprot.skip(ftype)
6930 
      else:
6931 
        iprot.skip(ftype)
6932 
      iprot.readFieldEnd()
6933 
    iprot.readStructEnd()
6934 
 
6935 
  def write(self, oprot):
6936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6938 
      return
6939 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 6940 
    if self.customerId is not None:
94 ashish 6941 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
6942 
      oprot.writeI64(self.customerId)
6943 
      oprot.writeFieldEnd()
3431 rajveer 6944 
    if self.from_date is not None:
94 ashish 6945 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
6946 
      oprot.writeI64(self.from_date)
6947 
      oprot.writeFieldEnd()
3431 rajveer 6948 
    if self.to_date is not None:
94 ashish 6949 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
6950 
      oprot.writeI64(self.to_date)
6951 
      oprot.writeFieldEnd()
3431 rajveer 6952 
    if self.status is not None:
94 ashish 6953 
      oprot.writeFieldBegin('status', TType.I32, 4)
6954 
      oprot.writeI32(self.status)
6955 
      oprot.writeFieldEnd()
6956 
    oprot.writeFieldStop()
6957 
    oprot.writeStructEnd()
6958 
 
3431 rajveer 6959 
  def validate(self):
6960 
    return
6961 
 
6962 
 
94 ashish 6963 
  def __repr__(self):
6964 
    L = ['%s=%r' % (key, value)
6965 
      for key, value in self.__dict__.iteritems()]
6966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6967 
 
6968 
  def __eq__(self, other):
6969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6970 
 
6971 
  def __ne__(self, other):
6972 
    return not (self == other)
6973 
 
6974 
class getTransactionsForCustomer_result:
6975 
  """
6976 
  Attributes:
6977 
   - success
6978 
   - ex
6979 
  """
6980 
 
6981 
  thrift_spec = (
6982 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
6983 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6984 
  )
6985 
 
6986 
  def __init__(self, success=None, ex=None,):
6987 
    self.success = success
6988 
    self.ex = ex
6989 
 
6990 
  def read(self, iprot):
6991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6993 
      return
6994 
    iprot.readStructBegin()
6995 
    while True:
6996 
      (fname, ftype, fid) = iprot.readFieldBegin()
6997 
      if ftype == TType.STOP:
6998 
        break
6999 
      if fid == 0:
7000 
        if ftype == TType.LIST:
7001 
          self.success = []
5031 varun.gupt 7002 
          (_etype66, _size63) = iprot.readListBegin()
7003 
          for _i67 in xrange(_size63):
7004 
            _elem68 = Transaction()
7005 
            _elem68.read(iprot)
7006 
            self.success.append(_elem68)
94 ashish 7007 
          iprot.readListEnd()
7008 
        else:
7009 
          iprot.skip(ftype)
7010 
      elif fid == 1:
7011 
        if ftype == TType.STRUCT:
7012 
          self.ex = TransactionServiceException()
7013 
          self.ex.read(iprot)
7014 
        else:
7015 
          iprot.skip(ftype)
7016 
      else:
7017 
        iprot.skip(ftype)
7018 
      iprot.readFieldEnd()
7019 
    iprot.readStructEnd()
7020 
 
7021 
  def write(self, oprot):
7022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7024 
      return
7025 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 7026 
    if self.success is not None:
94 ashish 7027 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7028 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7029 
      for iter69 in self.success:
7030 
        iter69.write(oprot)
94 ashish 7031 
      oprot.writeListEnd()
7032 
      oprot.writeFieldEnd()
3431 rajveer 7033 
    if self.ex is not None:
94 ashish 7034 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7035 
      self.ex.write(oprot)
7036 
      oprot.writeFieldEnd()
7037 
    oprot.writeFieldStop()
7038 
    oprot.writeStructEnd()
7039 
 
3431 rajveer 7040 
  def validate(self):
7041 
    return
7042 
 
7043 
 
94 ashish 7044 
  def __repr__(self):
7045 
    L = ['%s=%r' % (key, value)
7046 
      for key, value in self.__dict__.iteritems()]
7047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7048 
 
7049 
  def __eq__(self, other):
7050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7051 
 
7052 
  def __ne__(self, other):
7053 
    return not (self == other)
7054 
 
132 ashish 7055 
class getTransactionsForShoppingCartId_args:
7056 
  """
7057 
  Attributes:
7058 
   - shoppingCartId
7059 
  """
7060 
 
7061 
  thrift_spec = (
7062 
    None, # 0
7063 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
7064 
  )
7065 
 
7066 
  def __init__(self, shoppingCartId=None,):
7067 
    self.shoppingCartId = shoppingCartId
7068 
 
7069 
  def read(self, iprot):
7070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7072 
      return
7073 
    iprot.readStructBegin()
7074 
    while True:
7075 
      (fname, ftype, fid) = iprot.readFieldBegin()
7076 
      if ftype == TType.STOP:
7077 
        break
7078 
      if fid == 1:
7079 
        if ftype == TType.I64:
7080 
          self.shoppingCartId = iprot.readI64();
7081 
        else:
7082 
          iprot.skip(ftype)
7083 
      else:
7084 
        iprot.skip(ftype)
7085 
      iprot.readFieldEnd()
7086 
    iprot.readStructEnd()
7087 
 
7088 
  def write(self, oprot):
7089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7091 
      return
7092 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 7093 
    if self.shoppingCartId is not None:
132 ashish 7094 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
7095 
      oprot.writeI64(self.shoppingCartId)
7096 
      oprot.writeFieldEnd()
7097 
    oprot.writeFieldStop()
7098 
    oprot.writeStructEnd()
7099 
 
3431 rajveer 7100 
  def validate(self):
7101 
    return
7102 
 
7103 
 
132 ashish 7104 
  def __repr__(self):
7105 
    L = ['%s=%r' % (key, value)
7106 
      for key, value in self.__dict__.iteritems()]
7107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7108 
 
7109 
  def __eq__(self, other):
7110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7111 
 
7112 
  def __ne__(self, other):
7113 
    return not (self == other)
7114 
 
7115 
class getTransactionsForShoppingCartId_result:
7116 
  """
7117 
  Attributes:
7118 
   - success
7119 
   - ex
7120 
  """
7121 
 
7122 
  thrift_spec = (
7123 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7124 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7125 
  )
7126 
 
7127 
  def __init__(self, success=None, ex=None,):
7128 
    self.success = success
7129 
    self.ex = ex
7130 
 
7131 
  def read(self, iprot):
7132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7134 
      return
7135 
    iprot.readStructBegin()
7136 
    while True:
7137 
      (fname, ftype, fid) = iprot.readFieldBegin()
7138 
      if ftype == TType.STOP:
7139 
        break
7140 
      if fid == 0:
7141 
        if ftype == TType.LIST:
7142 
          self.success = []
5031 varun.gupt 7143 
          (_etype73, _size70) = iprot.readListBegin()
7144 
          for _i74 in xrange(_size70):
7145 
            _elem75 = Transaction()
7146 
            _elem75.read(iprot)
7147 
            self.success.append(_elem75)
132 ashish 7148 
          iprot.readListEnd()
7149 
        else:
7150 
          iprot.skip(ftype)
7151 
      elif fid == 1:
7152 
        if ftype == TType.STRUCT:
7153 
          self.ex = TransactionServiceException()
7154 
          self.ex.read(iprot)
7155 
        else:
7156 
          iprot.skip(ftype)
7157 
      else:
7158 
        iprot.skip(ftype)
7159 
      iprot.readFieldEnd()
7160 
    iprot.readStructEnd()
7161 
 
7162 
  def write(self, oprot):
7163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7165 
      return
7166 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 7167 
    if self.success is not None:
132 ashish 7168 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7169 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7170 
      for iter76 in self.success:
7171 
        iter76.write(oprot)
132 ashish 7172 
      oprot.writeListEnd()
7173 
      oprot.writeFieldEnd()
3431 rajveer 7174 
    if self.ex is not None:
132 ashish 7175 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7176 
      self.ex.write(oprot)
7177 
      oprot.writeFieldEnd()
7178 
    oprot.writeFieldStop()
7179 
    oprot.writeStructEnd()
7180 
 
3431 rajveer 7181 
  def validate(self):
7182 
    return
7183 
 
7184 
 
132 ashish 7185 
  def __repr__(self):
7186 
    L = ['%s=%r' % (key, value)
7187 
      for key, value in self.__dict__.iteritems()]
7188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7189 
 
7190 
  def __eq__(self, other):
7191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7192 
 
7193 
  def __ne__(self, other):
7194 
    return not (self == other)
7195 
 
94 ashish 7196 
class getTransactionStatus_args:
7197 
  """
7198 
  Attributes:
7199 
   - transactionId
7200 
  """
7201 
 
7202 
  thrift_spec = (
7203 
    None, # 0
7204 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7205 
  )
7206 
 
7207 
  def __init__(self, transactionId=None,):
7208 
    self.transactionId = transactionId
7209 
 
7210 
  def read(self, iprot):
7211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7213 
      return
7214 
    iprot.readStructBegin()
7215 
    while True:
7216 
      (fname, ftype, fid) = iprot.readFieldBegin()
7217 
      if ftype == TType.STOP:
7218 
        break
7219 
      if fid == 1:
7220 
        if ftype == TType.I64:
7221 
          self.transactionId = iprot.readI64();
7222 
        else:
7223 
          iprot.skip(ftype)
7224 
      else:
7225 
        iprot.skip(ftype)
7226 
      iprot.readFieldEnd()
7227 
    iprot.readStructEnd()
7228 
 
7229 
  def write(self, oprot):
7230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7232 
      return
7233 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 7234 
    if self.transactionId is not None:
94 ashish 7235 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7236 
      oprot.writeI64(self.transactionId)
7237 
      oprot.writeFieldEnd()
7238 
    oprot.writeFieldStop()
7239 
    oprot.writeStructEnd()
7240 
 
3431 rajveer 7241 
  def validate(self):
7242 
    return
7243 
 
7244 
 
94 ashish 7245 
  def __repr__(self):
7246 
    L = ['%s=%r' % (key, value)
7247 
      for key, value in self.__dict__.iteritems()]
7248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7249 
 
7250 
  def __eq__(self, other):
7251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7252 
 
7253 
  def __ne__(self, other):
7254 
    return not (self == other)
7255 
 
7256 
class getTransactionStatus_result:
7257 
  """
7258 
  Attributes:
7259 
   - success
7260 
   - ex
7261 
  """
7262 
 
7263 
  thrift_spec = (
7264 
    (0, TType.I32, 'success', None, None, ), # 0
7265 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7266 
  )
7267 
 
7268 
  def __init__(self, success=None, ex=None,):
7269 
    self.success = success
7270 
    self.ex = ex
7271 
 
7272 
  def read(self, iprot):
7273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7275 
      return
7276 
    iprot.readStructBegin()
7277 
    while True:
7278 
      (fname, ftype, fid) = iprot.readFieldBegin()
7279 
      if ftype == TType.STOP:
7280 
        break
7281 
      if fid == 0:
7282 
        if ftype == TType.I32:
7283 
          self.success = iprot.readI32();
7284 
        else:
7285 
          iprot.skip(ftype)
7286 
      elif fid == 1:
7287 
        if ftype == TType.STRUCT:
7288 
          self.ex = TransactionServiceException()
7289 
          self.ex.read(iprot)
7290 
        else:
7291 
          iprot.skip(ftype)
7292 
      else:
7293 
        iprot.skip(ftype)
7294 
      iprot.readFieldEnd()
7295 
    iprot.readStructEnd()
7296 
 
7297 
  def write(self, oprot):
7298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7300 
      return
7301 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 7302 
    if self.success is not None:
94 ashish 7303 
      oprot.writeFieldBegin('success', TType.I32, 0)
7304 
      oprot.writeI32(self.success)
7305 
      oprot.writeFieldEnd()
3431 rajveer 7306 
    if self.ex is not None:
94 ashish 7307 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7308 
      self.ex.write(oprot)
7309 
      oprot.writeFieldEnd()
7310 
    oprot.writeFieldStop()
7311 
    oprot.writeStructEnd()
7312 
 
3431 rajveer 7313 
  def validate(self):
7314 
    return
7315 
 
7316 
 
94 ashish 7317 
  def __repr__(self):
7318 
    L = ['%s=%r' % (key, value)
7319 
      for key, value in self.__dict__.iteritems()]
7320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7321 
 
7322 
  def __eq__(self, other):
7323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7324 
 
7325 
  def __ne__(self, other):
7326 
    return not (self == other)
7327 
 
7328 
class changeTransactionStatus_args:
7329 
  """
7330 
  Attributes:
7331 
   - transactionId
7332 
   - status
7333 
   - description
7334 
  """
7335 
 
7336 
  thrift_spec = (
7337 
    None, # 0
7338 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7339 
    (2, TType.I32, 'status', None, None, ), # 2
7340 
    (3, TType.STRING, 'description', None, None, ), # 3
7341 
  )
7342 
 
7343 
  def __init__(self, transactionId=None, status=None, description=None,):
7344 
    self.transactionId = transactionId
7345 
    self.status = status
7346 
    self.description = description
7347 
 
7348 
  def read(self, iprot):
7349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7351 
      return
7352 
    iprot.readStructBegin()
7353 
    while True:
7354 
      (fname, ftype, fid) = iprot.readFieldBegin()
7355 
      if ftype == TType.STOP:
7356 
        break
7357 
      if fid == 1:
7358 
        if ftype == TType.I64:
7359 
          self.transactionId = iprot.readI64();
7360 
        else:
7361 
          iprot.skip(ftype)
7362 
      elif fid == 2:
7363 
        if ftype == TType.I32:
7364 
          self.status = iprot.readI32();
7365 
        else:
7366 
          iprot.skip(ftype)
7367 
      elif fid == 3:
7368 
        if ftype == TType.STRING:
7369 
          self.description = iprot.readString();
7370 
        else:
7371 
          iprot.skip(ftype)
7372 
      else:
7373 
        iprot.skip(ftype)
7374 
      iprot.readFieldEnd()
7375 
    iprot.readStructEnd()
7376 
 
7377 
  def write(self, oprot):
7378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7380 
      return
7381 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 7382 
    if self.transactionId is not None:
94 ashish 7383 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7384 
      oprot.writeI64(self.transactionId)
7385 
      oprot.writeFieldEnd()
3431 rajveer 7386 
    if self.status is not None:
94 ashish 7387 
      oprot.writeFieldBegin('status', TType.I32, 2)
7388 
      oprot.writeI32(self.status)
7389 
      oprot.writeFieldEnd()
3431 rajveer 7390 
    if self.description is not None:
94 ashish 7391 
      oprot.writeFieldBegin('description', TType.STRING, 3)
7392 
      oprot.writeString(self.description)
7393 
      oprot.writeFieldEnd()
7394 
    oprot.writeFieldStop()
7395 
    oprot.writeStructEnd()
7396 
 
3431 rajveer 7397 
  def validate(self):
7398 
    return
7399 
 
7400 
 
94 ashish 7401 
  def __repr__(self):
7402 
    L = ['%s=%r' % (key, value)
7403 
      for key, value in self.__dict__.iteritems()]
7404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7405 
 
7406 
  def __eq__(self, other):
7407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7408 
 
7409 
  def __ne__(self, other):
7410 
    return not (self == other)
7411 
 
7412 
class changeTransactionStatus_result:
7413 
  """
7414 
  Attributes:
7415 
   - success
7416 
   - ex
7417 
  """
7418 
 
7419 
  thrift_spec = (
7420 
    (0, TType.BOOL, 'success', None, None, ), # 0
7421 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7422 
  )
7423 
 
7424 
  def __init__(self, success=None, ex=None,):
7425 
    self.success = success
7426 
    self.ex = ex
7427 
 
7428 
  def read(self, iprot):
7429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7431 
      return
7432 
    iprot.readStructBegin()
7433 
    while True:
7434 
      (fname, ftype, fid) = iprot.readFieldBegin()
7435 
      if ftype == TType.STOP:
7436 
        break
7437 
      if fid == 0:
7438 
        if ftype == TType.BOOL:
7439 
          self.success = iprot.readBool();
7440 
        else:
7441 
          iprot.skip(ftype)
7442 
      elif fid == 1:
7443 
        if ftype == TType.STRUCT:
7444 
          self.ex = TransactionServiceException()
7445 
          self.ex.read(iprot)
7446 
        else:
7447 
          iprot.skip(ftype)
7448 
      else:
7449 
        iprot.skip(ftype)
7450 
      iprot.readFieldEnd()
7451 
    iprot.readStructEnd()
7452 
 
7453 
  def write(self, oprot):
7454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7456 
      return
7457 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 7458 
    if self.success is not None:
94 ashish 7459 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7460 
      oprot.writeBool(self.success)
7461 
      oprot.writeFieldEnd()
3431 rajveer 7462 
    if self.ex is not None:
94 ashish 7463 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7464 
      self.ex.write(oprot)
7465 
      oprot.writeFieldEnd()
7466 
    oprot.writeFieldStop()
7467 
    oprot.writeStructEnd()
7468 
 
3431 rajveer 7469 
  def validate(self):
7470 
    return
7471 
 
7472 
 
94 ashish 7473 
  def __repr__(self):
7474 
    L = ['%s=%r' % (key, value)
7475 
      for key, value in self.__dict__.iteritems()]
7476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7477 
 
7478 
  def __eq__(self, other):
7479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7480 
 
7481 
  def __ne__(self, other):
7482 
    return not (self == other)
7483 
 
1398 varun.gupt 7484 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 7485 
  """
7486 
  Attributes:
7487 
   - transactionId
7488 
  """
7489 
 
7490 
  thrift_spec = (
7491 
    None, # 0
7492 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7493 
  )
7494 
 
7495 
  def __init__(self, transactionId=None,):
7496 
    self.transactionId = transactionId
7497 
 
7498 
  def read(self, iprot):
7499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7501 
      return
7502 
    iprot.readStructBegin()
7503 
    while True:
7504 
      (fname, ftype, fid) = iprot.readFieldBegin()
7505 
      if ftype == TType.STOP:
7506 
        break
7507 
      if fid == 1:
7508 
        if ftype == TType.I64:
7509 
          self.transactionId = iprot.readI64();
7510 
        else:
7511 
          iprot.skip(ftype)
7512 
      else:
7513 
        iprot.skip(ftype)
7514 
      iprot.readFieldEnd()
7515 
    iprot.readStructEnd()
7516 
 
7517 
  def write(self, oprot):
7518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7520 
      return
1398 varun.gupt 7521 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 7522 
    if self.transactionId is not None:
1382 varun.gupt 7523 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
7524 
      oprot.writeI64(self.transactionId)
7525 
      oprot.writeFieldEnd()
7526 
    oprot.writeFieldStop()
7527 
    oprot.writeStructEnd()
7528 
 
3431 rajveer 7529 
  def validate(self):
7530 
    return
7531 
 
7532 
 
1382 varun.gupt 7533 
  def __repr__(self):
7534 
    L = ['%s=%r' % (key, value)
7535 
      for key, value in self.__dict__.iteritems()]
7536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7537 
 
7538 
  def __eq__(self, other):
7539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7540 
 
7541 
  def __ne__(self, other):
7542 
    return not (self == other)
7543 
 
1398 varun.gupt 7544 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 7545 
  """
7546 
  Attributes:
7547 
   - success
7548 
   - ex
7549 
  """
7550 
 
7551 
  thrift_spec = (
7552 
    (0, TType.BOOL, 'success', None, None, ), # 0
7553 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7554 
  )
7555 
 
7556 
  def __init__(self, success=None, ex=None,):
7557 
    self.success = success
7558 
    self.ex = ex
7559 
 
7560 
  def read(self, iprot):
7561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7563 
      return
7564 
    iprot.readStructBegin()
7565 
    while True:
7566 
      (fname, ftype, fid) = iprot.readFieldBegin()
7567 
      if ftype == TType.STOP:
7568 
        break
7569 
      if fid == 0:
7570 
        if ftype == TType.BOOL:
7571 
          self.success = iprot.readBool();
7572 
        else:
7573 
          iprot.skip(ftype)
7574 
      elif fid == 1:
7575 
        if ftype == TType.STRUCT:
7576 
          self.ex = TransactionServiceException()
7577 
          self.ex.read(iprot)
7578 
        else:
7579 
          iprot.skip(ftype)
7580 
      else:
7581 
        iprot.skip(ftype)
7582 
      iprot.readFieldEnd()
7583 
    iprot.readStructEnd()
7584 
 
7585 
  def write(self, oprot):
7586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7588 
      return
1398 varun.gupt 7589 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 7590 
    if self.success is not None:
1382 varun.gupt 7591 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7592 
      oprot.writeBool(self.success)
7593 
      oprot.writeFieldEnd()
3431 rajveer 7594 
    if self.ex is not None:
1382 varun.gupt 7595 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7596 
      self.ex.write(oprot)
7597 
      oprot.writeFieldEnd()
7598 
    oprot.writeFieldStop()
7599 
    oprot.writeStructEnd()
7600 
 
3431 rajveer 7601 
  def validate(self):
7602 
    return
7603 
 
7604 
 
1382 varun.gupt 7605 
  def __repr__(self):
7606 
    L = ['%s=%r' % (key, value)
7607 
      for key, value in self.__dict__.iteritems()]
7608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7609 
 
7610 
  def __eq__(self, other):
7611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7612 
 
7613 
  def __ne__(self, other):
7614 
    return not (self == other)
7615 
 
483 rajveer 7616 
class getAllOrders_args:
94 ashish 7617 
  """
7618 
  Attributes:
4801 anupam.sin 7619 
   - statuses
483 rajveer 7620 
   - from_date
7621 
   - to_date
7622 
   - warehouse_id
94 ashish 7623 
  """
7624 
 
7625 
  thrift_spec = (
7626 
    None, # 0
4801 anupam.sin 7627 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 7628 
    (2, TType.I64, 'from_date', None, None, ), # 2
7629 
    (3, TType.I64, 'to_date', None, None, ), # 3
7630 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 7631 
  )
7632 
 
4801 anupam.sin 7633 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
7634 
    self.statuses = statuses
483 rajveer 7635 
    self.from_date = from_date
7636 
    self.to_date = to_date
7637 
    self.warehouse_id = warehouse_id
94 ashish 7638 
 
7639 
  def read(self, iprot):
7640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7642 
      return
7643 
    iprot.readStructBegin()
7644 
    while True:
7645 
      (fname, ftype, fid) = iprot.readFieldBegin()
7646 
      if ftype == TType.STOP:
7647 
        break
7648 
      if fid == 1:
4801 anupam.sin 7649 
        if ftype == TType.LIST:
7650 
          self.statuses = []
5031 varun.gupt 7651 
          (_etype80, _size77) = iprot.readListBegin()
7652 
          for _i81 in xrange(_size77):
7653 
            _elem82 = iprot.readI32();
7654 
            self.statuses.append(_elem82)
4801 anupam.sin 7655 
          iprot.readListEnd()
94 ashish 7656 
        else:
7657 
          iprot.skip(ftype)
483 rajveer 7658 
      elif fid == 2:
7659 
        if ftype == TType.I64:
7660 
          self.from_date = iprot.readI64();
94 ashish 7661 
        else:
7662 
          iprot.skip(ftype)
483 rajveer 7663 
      elif fid == 3:
7664 
        if ftype == TType.I64:
7665 
          self.to_date = iprot.readI64();
94 ashish 7666 
        else:
7667 
          iprot.skip(ftype)
483 rajveer 7668 
      elif fid == 4:
94 ashish 7669 
        if ftype == TType.I64:
483 rajveer 7670 
          self.warehouse_id = iprot.readI64();
94 ashish 7671 
        else:
7672 
          iprot.skip(ftype)
7673 
      else:
7674 
        iprot.skip(ftype)
7675 
      iprot.readFieldEnd()
7676 
    iprot.readStructEnd()
7677 
 
7678 
  def write(self, oprot):
7679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7681 
      return
483 rajveer 7682 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 7683 
    if self.statuses is not None:
7684 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7685 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7686 
      for iter83 in self.statuses:
7687 
        oprot.writeI32(iter83)
4801 anupam.sin 7688 
      oprot.writeListEnd()
94 ashish 7689 
      oprot.writeFieldEnd()
3431 rajveer 7690 
    if self.from_date is not None:
483 rajveer 7691 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7692 
      oprot.writeI64(self.from_date)
94 ashish 7693 
      oprot.writeFieldEnd()
3431 rajveer 7694 
    if self.to_date is not None:
483 rajveer 7695 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7696 
      oprot.writeI64(self.to_date)
94 ashish 7697 
      oprot.writeFieldEnd()
3431 rajveer 7698 
    if self.warehouse_id is not None:
483 rajveer 7699 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7700 
      oprot.writeI64(self.warehouse_id)
94 ashish 7701 
      oprot.writeFieldEnd()
7702 
    oprot.writeFieldStop()
7703 
    oprot.writeStructEnd()
7704 
 
3431 rajveer 7705 
  def validate(self):
7706 
    return
7707 
 
7708 
 
94 ashish 7709 
  def __repr__(self):
7710 
    L = ['%s=%r' % (key, value)
7711 
      for key, value in self.__dict__.iteritems()]
7712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7713 
 
7714 
  def __eq__(self, other):
7715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7716 
 
7717 
  def __ne__(self, other):
7718 
    return not (self == other)
7719 
 
483 rajveer 7720 
class getAllOrders_result:
94 ashish 7721 
  """
7722 
  Attributes:
7723 
   - success
7724 
   - ex
7725 
  """
7726 
 
7727 
  thrift_spec = (
483 rajveer 7728 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 7729 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7730 
  )
7731 
 
7732 
  def __init__(self, success=None, ex=None,):
7733 
    self.success = success
7734 
    self.ex = ex
7735 
 
7736 
  def read(self, iprot):
7737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7739 
      return
7740 
    iprot.readStructBegin()
7741 
    while True:
7742 
      (fname, ftype, fid) = iprot.readFieldBegin()
7743 
      if ftype == TType.STOP:
7744 
        break
7745 
      if fid == 0:
483 rajveer 7746 
        if ftype == TType.LIST:
7747 
          self.success = []
5031 varun.gupt 7748 
          (_etype87, _size84) = iprot.readListBegin()
7749 
          for _i88 in xrange(_size84):
7750 
            _elem89 = Order()
7751 
            _elem89.read(iprot)
7752 
            self.success.append(_elem89)
483 rajveer 7753 
          iprot.readListEnd()
94 ashish 7754 
        else:
7755 
          iprot.skip(ftype)
7756 
      elif fid == 1:
7757 
        if ftype == TType.STRUCT:
7758 
          self.ex = TransactionServiceException()
7759 
          self.ex.read(iprot)
7760 
        else:
7761 
          iprot.skip(ftype)
7762 
      else:
7763 
        iprot.skip(ftype)
7764 
      iprot.readFieldEnd()
7765 
    iprot.readStructEnd()
7766 
 
7767 
  def write(self, oprot):
7768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7770 
      return
483 rajveer 7771 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 7772 
    if self.success is not None:
483 rajveer 7773 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7774 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7775 
      for iter90 in self.success:
7776 
        iter90.write(oprot)
483 rajveer 7777 
      oprot.writeListEnd()
94 ashish 7778 
      oprot.writeFieldEnd()
3431 rajveer 7779 
    if self.ex is not None:
94 ashish 7780 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7781 
      self.ex.write(oprot)
7782 
      oprot.writeFieldEnd()
7783 
    oprot.writeFieldStop()
7784 
    oprot.writeStructEnd()
7785 
 
3431 rajveer 7786 
  def validate(self):
7787 
    return
7788 
 
7789 
 
94 ashish 7790 
  def __repr__(self):
7791 
    L = ['%s=%r' % (key, value)
7792 
      for key, value in self.__dict__.iteritems()]
7793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7794 
 
7795 
  def __eq__(self, other):
7796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7797 
 
7798 
  def __ne__(self, other):
7799 
    return not (self == other)
7800 
 
4133 chandransh 7801 
class getOrdersInBatch_args:
7802 
  """
7803 
  Attributes:
7804 
   - statuses
7805 
   - offset
7806 
   - limit
7807 
   - warehouse_id
7808 
  """
7809 
 
7810 
  thrift_spec = (
7811 
    None, # 0
7812 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7813 
    (2, TType.I64, 'offset', None, None, ), # 2
7814 
    (3, TType.I64, 'limit', None, None, ), # 3
7815 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
7816 
  )
7817 
 
7818 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
7819 
    self.statuses = statuses
7820 
    self.offset = offset
7821 
    self.limit = limit
7822 
    self.warehouse_id = warehouse_id
7823 
 
7824 
  def read(self, iprot):
7825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7827 
      return
7828 
    iprot.readStructBegin()
7829 
    while True:
7830 
      (fname, ftype, fid) = iprot.readFieldBegin()
7831 
      if ftype == TType.STOP:
7832 
        break
7833 
      if fid == 1:
7834 
        if ftype == TType.LIST:
7835 
          self.statuses = []
5031 varun.gupt 7836 
          (_etype94, _size91) = iprot.readListBegin()
7837 
          for _i95 in xrange(_size91):
7838 
            _elem96 = iprot.readI32();
7839 
            self.statuses.append(_elem96)
4133 chandransh 7840 
          iprot.readListEnd()
7841 
        else:
7842 
          iprot.skip(ftype)
7843 
      elif fid == 2:
7844 
        if ftype == TType.I64:
7845 
          self.offset = iprot.readI64();
7846 
        else:
7847 
          iprot.skip(ftype)
7848 
      elif fid == 3:
7849 
        if ftype == TType.I64:
7850 
          self.limit = iprot.readI64();
7851 
        else:
7852 
          iprot.skip(ftype)
7853 
      elif fid == 4:
7854 
        if ftype == TType.I64:
7855 
          self.warehouse_id = iprot.readI64();
7856 
        else:
7857 
          iprot.skip(ftype)
7858 
      else:
7859 
        iprot.skip(ftype)
7860 
      iprot.readFieldEnd()
7861 
    iprot.readStructEnd()
7862 
 
7863 
  def write(self, oprot):
7864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7866 
      return
7867 
    oprot.writeStructBegin('getOrdersInBatch_args')
7868 
    if self.statuses is not None:
7869 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
7870 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 7871 
      for iter97 in self.statuses:
7872 
        oprot.writeI32(iter97)
4133 chandransh 7873 
      oprot.writeListEnd()
7874 
      oprot.writeFieldEnd()
7875 
    if self.offset is not None:
7876 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7877 
      oprot.writeI64(self.offset)
7878 
      oprot.writeFieldEnd()
7879 
    if self.limit is not None:
7880 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7881 
      oprot.writeI64(self.limit)
7882 
      oprot.writeFieldEnd()
7883 
    if self.warehouse_id is not None:
7884 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
7885 
      oprot.writeI64(self.warehouse_id)
7886 
      oprot.writeFieldEnd()
7887 
    oprot.writeFieldStop()
7888 
    oprot.writeStructEnd()
7889 
 
7890 
  def validate(self):
7891 
    return
7892 
 
7893 
 
7894 
  def __repr__(self):
7895 
    L = ['%s=%r' % (key, value)
7896 
      for key, value in self.__dict__.iteritems()]
7897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7898 
 
7899 
  def __eq__(self, other):
7900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7901 
 
7902 
  def __ne__(self, other):
7903 
    return not (self == other)
7904 
 
7905 
class getOrdersInBatch_result:
7906 
  """
7907 
  Attributes:
7908 
   - success
7909 
   - ex
7910 
  """
7911 
 
7912 
  thrift_spec = (
7913 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7914 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7915 
  )
7916 
 
7917 
  def __init__(self, success=None, ex=None,):
7918 
    self.success = success
7919 
    self.ex = ex
7920 
 
7921 
  def read(self, iprot):
7922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7924 
      return
7925 
    iprot.readStructBegin()
7926 
    while True:
7927 
      (fname, ftype, fid) = iprot.readFieldBegin()
7928 
      if ftype == TType.STOP:
7929 
        break
7930 
      if fid == 0:
7931 
        if ftype == TType.LIST:
7932 
          self.success = []
5031 varun.gupt 7933 
          (_etype101, _size98) = iprot.readListBegin()
7934 
          for _i102 in xrange(_size98):
7935 
            _elem103 = Order()
7936 
            _elem103.read(iprot)
7937 
            self.success.append(_elem103)
4133 chandransh 7938 
          iprot.readListEnd()
7939 
        else:
7940 
          iprot.skip(ftype)
7941 
      elif fid == 1:
7942 
        if ftype == TType.STRUCT:
7943 
          self.ex = TransactionServiceException()
7944 
          self.ex.read(iprot)
7945 
        else:
7946 
          iprot.skip(ftype)
7947 
      else:
7948 
        iprot.skip(ftype)
7949 
      iprot.readFieldEnd()
7950 
    iprot.readStructEnd()
7951 
 
7952 
  def write(self, oprot):
7953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7955 
      return
7956 
    oprot.writeStructBegin('getOrdersInBatch_result')
7957 
    if self.success is not None:
7958 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7959 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7960 
      for iter104 in self.success:
7961 
        iter104.write(oprot)
4133 chandransh 7962 
      oprot.writeListEnd()
7963 
      oprot.writeFieldEnd()
7964 
    if self.ex is not None:
7965 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7966 
      self.ex.write(oprot)
7967 
      oprot.writeFieldEnd()
7968 
    oprot.writeFieldStop()
7969 
    oprot.writeStructEnd()
7970 
 
7971 
  def validate(self):
7972 
    return
7973 
 
7974 
 
7975 
  def __repr__(self):
7976 
    L = ['%s=%r' % (key, value)
7977 
      for key, value in self.__dict__.iteritems()]
7978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7979 
 
7980 
  def __eq__(self, other):
7981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7982 
 
7983 
  def __ne__(self, other):
7984 
    return not (self == other)
7985 
 
7986 
class getOrderCount_args:
7987 
  """
7988 
  Attributes:
7989 
   - statuses
7990 
   - warehouseId
7991 
  """
7992 
 
7993 
  thrift_spec = (
7994 
    None, # 0
7995 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
7996 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7997 
  )
7998 
 
7999 
  def __init__(self, statuses=None, warehouseId=None,):
8000 
    self.statuses = statuses
8001 
    self.warehouseId = warehouseId
8002 
 
8003 
  def read(self, iprot):
8004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8006 
      return
8007 
    iprot.readStructBegin()
8008 
    while True:
8009 
      (fname, ftype, fid) = iprot.readFieldBegin()
8010 
      if ftype == TType.STOP:
8011 
        break
8012 
      if fid == 1:
8013 
        if ftype == TType.LIST:
8014 
          self.statuses = []
5031 varun.gupt 8015 
          (_etype108, _size105) = iprot.readListBegin()
8016 
          for _i109 in xrange(_size105):
8017 
            _elem110 = iprot.readI32();
8018 
            self.statuses.append(_elem110)
4133 chandransh 8019 
          iprot.readListEnd()
8020 
        else:
8021 
          iprot.skip(ftype)
8022 
      elif fid == 2:
8023 
        if ftype == TType.I64:
8024 
          self.warehouseId = iprot.readI64();
8025 
        else:
8026 
          iprot.skip(ftype)
8027 
      else:
8028 
        iprot.skip(ftype)
8029 
      iprot.readFieldEnd()
8030 
    iprot.readStructEnd()
8031 
 
8032 
  def write(self, oprot):
8033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8035 
      return
8036 
    oprot.writeStructBegin('getOrderCount_args')
8037 
    if self.statuses is not None:
8038 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8039 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8040 
      for iter111 in self.statuses:
8041 
        oprot.writeI32(iter111)
4133 chandransh 8042 
      oprot.writeListEnd()
8043 
      oprot.writeFieldEnd()
8044 
    if self.warehouseId is not None:
8045 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8046 
      oprot.writeI64(self.warehouseId)
8047 
      oprot.writeFieldEnd()
8048 
    oprot.writeFieldStop()
8049 
    oprot.writeStructEnd()
8050 
 
8051 
  def validate(self):
8052 
    return
8053 
 
8054 
 
8055 
  def __repr__(self):
8056 
    L = ['%s=%r' % (key, value)
8057 
      for key, value in self.__dict__.iteritems()]
8058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8059 
 
8060 
  def __eq__(self, other):
8061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8062 
 
8063 
  def __ne__(self, other):
8064 
    return not (self == other)
8065 
 
8066 
class getOrderCount_result:
8067 
  """
8068 
  Attributes:
8069 
   - success
8070 
   - ex
8071 
  """
8072 
 
8073 
  thrift_spec = (
8074 
    (0, TType.I32, 'success', None, None, ), # 0
8075 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8076 
  )
8077 
 
8078 
  def __init__(self, success=None, ex=None,):
8079 
    self.success = success
8080 
    self.ex = ex
8081 
 
8082 
  def read(self, iprot):
8083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8085 
      return
8086 
    iprot.readStructBegin()
8087 
    while True:
8088 
      (fname, ftype, fid) = iprot.readFieldBegin()
8089 
      if ftype == TType.STOP:
8090 
        break
8091 
      if fid == 0:
8092 
        if ftype == TType.I32:
8093 
          self.success = iprot.readI32();
8094 
        else:
8095 
          iprot.skip(ftype)
8096 
      elif fid == 1:
8097 
        if ftype == TType.STRUCT:
8098 
          self.ex = TransactionServiceException()
8099 
          self.ex.read(iprot)
8100 
        else:
8101 
          iprot.skip(ftype)
8102 
      else:
8103 
        iprot.skip(ftype)
8104 
      iprot.readFieldEnd()
8105 
    iprot.readStructEnd()
8106 
 
8107 
  def write(self, oprot):
8108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8110 
      return
8111 
    oprot.writeStructBegin('getOrderCount_result')
8112 
    if self.success is not None:
8113 
      oprot.writeFieldBegin('success', TType.I32, 0)
8114 
      oprot.writeI32(self.success)
8115 
      oprot.writeFieldEnd()
8116 
    if self.ex is not None:
8117 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8118 
      self.ex.write(oprot)
8119 
      oprot.writeFieldEnd()
8120 
    oprot.writeFieldStop()
8121 
    oprot.writeStructEnd()
8122 
 
8123 
  def validate(self):
8124 
    return
8125 
 
8126 
 
8127 
  def __repr__(self):
8128 
    L = ['%s=%r' % (key, value)
8129 
      for key, value in self.__dict__.iteritems()]
8130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8131 
 
8132 
  def __eq__(self, other):
8133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8134 
 
8135 
  def __ne__(self, other):
8136 
    return not (self == other)
8137 
 
999 varun.gupt 8138 
class getOrdersByBillingDate_args:
8139 
  """
8140 
  Attributes:
8141 
   - status
8142 
   - start_billing_date
8143 
   - end_billing_date
8144 
   - warehouse_id
8145 
  """
8146 
 
8147 
  thrift_spec = (
8148 
    None, # 0
8149 
    (1, TType.I32, 'status', None, None, ), # 1
8150 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
8151 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
8152 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8153 
  )
8154 
 
8155 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
8156 
    self.status = status
8157 
    self.start_billing_date = start_billing_date
8158 
    self.end_billing_date = end_billing_date
8159 
    self.warehouse_id = warehouse_id
8160 
 
8161 
  def read(self, iprot):
8162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8164 
      return
8165 
    iprot.readStructBegin()
8166 
    while True:
8167 
      (fname, ftype, fid) = iprot.readFieldBegin()
8168 
      if ftype == TType.STOP:
8169 
        break
8170 
      if fid == 1:
8171 
        if ftype == TType.I32:
8172 
          self.status = iprot.readI32();
8173 
        else:
8174 
          iprot.skip(ftype)
8175 
      elif fid == 2:
8176 
        if ftype == TType.I64:
8177 
          self.start_billing_date = iprot.readI64();
8178 
        else:
8179 
          iprot.skip(ftype)
8180 
      elif fid == 3:
8181 
        if ftype == TType.I64:
8182 
          self.end_billing_date = iprot.readI64();
8183 
        else:
8184 
          iprot.skip(ftype)
8185 
      elif fid == 4:
8186 
        if ftype == TType.I64:
8187 
          self.warehouse_id = iprot.readI64();
8188 
        else:
8189 
          iprot.skip(ftype)
8190 
      else:
8191 
        iprot.skip(ftype)
8192 
      iprot.readFieldEnd()
8193 
    iprot.readStructEnd()
8194 
 
8195 
  def write(self, oprot):
8196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8198 
      return
8199 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 8200 
    if self.status is not None:
999 varun.gupt 8201 
      oprot.writeFieldBegin('status', TType.I32, 1)
8202 
      oprot.writeI32(self.status)
8203 
      oprot.writeFieldEnd()
3431 rajveer 8204 
    if self.start_billing_date is not None:
999 varun.gupt 8205 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
8206 
      oprot.writeI64(self.start_billing_date)
8207 
      oprot.writeFieldEnd()
3431 rajveer 8208 
    if self.end_billing_date is not None:
999 varun.gupt 8209 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
8210 
      oprot.writeI64(self.end_billing_date)
8211 
      oprot.writeFieldEnd()
3431 rajveer 8212 
    if self.warehouse_id is not None:
999 varun.gupt 8213 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8214 
      oprot.writeI64(self.warehouse_id)
8215 
      oprot.writeFieldEnd()
8216 
    oprot.writeFieldStop()
8217 
    oprot.writeStructEnd()
8218 
 
3431 rajveer 8219 
  def validate(self):
8220 
    return
8221 
 
8222 
 
999 varun.gupt 8223 
  def __repr__(self):
8224 
    L = ['%s=%r' % (key, value)
8225 
      for key, value in self.__dict__.iteritems()]
8226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8227 
 
8228 
  def __eq__(self, other):
8229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8230 
 
8231 
  def __ne__(self, other):
8232 
    return not (self == other)
8233 
 
8234 
class getOrdersByBillingDate_result:
8235 
  """
8236 
  Attributes:
8237 
   - success
8238 
   - ex
8239 
  """
8240 
 
8241 
  thrift_spec = (
8242 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8243 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8244 
  )
8245 
 
8246 
  def __init__(self, success=None, ex=None,):
8247 
    self.success = success
8248 
    self.ex = ex
8249 
 
8250 
  def read(self, iprot):
8251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8253 
      return
8254 
    iprot.readStructBegin()
8255 
    while True:
8256 
      (fname, ftype, fid) = iprot.readFieldBegin()
8257 
      if ftype == TType.STOP:
8258 
        break
8259 
      if fid == 0:
8260 
        if ftype == TType.LIST:
8261 
          self.success = []
5031 varun.gupt 8262 
          (_etype115, _size112) = iprot.readListBegin()
8263 
          for _i116 in xrange(_size112):
8264 
            _elem117 = Order()
8265 
            _elem117.read(iprot)
8266 
            self.success.append(_elem117)
999 varun.gupt 8267 
          iprot.readListEnd()
8268 
        else:
8269 
          iprot.skip(ftype)
8270 
      elif fid == 1:
8271 
        if ftype == TType.STRUCT:
8272 
          self.ex = TransactionServiceException()
8273 
          self.ex.read(iprot)
8274 
        else:
8275 
          iprot.skip(ftype)
8276 
      else:
8277 
        iprot.skip(ftype)
8278 
      iprot.readFieldEnd()
8279 
    iprot.readStructEnd()
8280 
 
8281 
  def write(self, oprot):
8282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8284 
      return
8285 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 8286 
    if self.success is not None:
999 varun.gupt 8287 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8288 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8289 
      for iter118 in self.success:
8290 
        iter118.write(oprot)
999 varun.gupt 8291 
      oprot.writeListEnd()
8292 
      oprot.writeFieldEnd()
3431 rajveer 8293 
    if self.ex is not None:
999 varun.gupt 8294 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8295 
      self.ex.write(oprot)
8296 
      oprot.writeFieldEnd()
8297 
    oprot.writeFieldStop()
8298 
    oprot.writeStructEnd()
8299 
 
3431 rajveer 8300 
  def validate(self):
8301 
    return
8302 
 
8303 
 
999 varun.gupt 8304 
  def __repr__(self):
8305 
    L = ['%s=%r' % (key, value)
8306 
      for key, value in self.__dict__.iteritems()]
8307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8308 
 
8309 
  def __eq__(self, other):
8310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8311 
 
8312 
  def __ne__(self, other):
8313 
    return not (self == other)
8314 
 
3427 chandransh 8315 
class getOrdersByShippingDate_args:
8316 
  """
8317 
  Attributes:
8318 
   - fromShippingDate
8319 
   - toShippingDate
8320 
   - providerId
8321 
   - warehouseId
3451 chandransh 8322 
   - cod
3427 chandransh 8323 
  """
8324 
 
8325 
  thrift_spec = (
8326 
    None, # 0
8327 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
8328 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
8329 
    (3, TType.I64, 'providerId', None, None, ), # 3
8330 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 8331 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 8332 
  )
8333 
 
3451 chandransh 8334 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 8335 
    self.fromShippingDate = fromShippingDate
8336 
    self.toShippingDate = toShippingDate
8337 
    self.providerId = providerId
8338 
    self.warehouseId = warehouseId
3451 chandransh 8339 
    self.cod = cod
3427 chandransh 8340 
 
8341 
  def read(self, iprot):
8342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8344 
      return
8345 
    iprot.readStructBegin()
8346 
    while True:
8347 
      (fname, ftype, fid) = iprot.readFieldBegin()
8348 
      if ftype == TType.STOP:
8349 
        break
8350 
      if fid == 1:
8351 
        if ftype == TType.I64:
8352 
          self.fromShippingDate = iprot.readI64();
8353 
        else:
8354 
          iprot.skip(ftype)
8355 
      elif fid == 2:
8356 
        if ftype == TType.I64:
8357 
          self.toShippingDate = iprot.readI64();
8358 
        else:
8359 
          iprot.skip(ftype)
8360 
      elif fid == 3:
8361 
        if ftype == TType.I64:
8362 
          self.providerId = iprot.readI64();
8363 
        else:
8364 
          iprot.skip(ftype)
8365 
      elif fid == 4:
8366 
        if ftype == TType.I64:
8367 
          self.warehouseId = iprot.readI64();
8368 
        else:
8369 
          iprot.skip(ftype)
3451 chandransh 8370 
      elif fid == 5:
8371 
        if ftype == TType.BOOL:
8372 
          self.cod = iprot.readBool();
8373 
        else:
8374 
          iprot.skip(ftype)
3427 chandransh 8375 
      else:
8376 
        iprot.skip(ftype)
8377 
      iprot.readFieldEnd()
8378 
    iprot.readStructEnd()
8379 
 
8380 
  def write(self, oprot):
8381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8383 
      return
8384 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 8385 
    if self.fromShippingDate is not None:
3427 chandransh 8386 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
8387 
      oprot.writeI64(self.fromShippingDate)
8388 
      oprot.writeFieldEnd()
3431 rajveer 8389 
    if self.toShippingDate is not None:
3427 chandransh 8390 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
8391 
      oprot.writeI64(self.toShippingDate)
8392 
      oprot.writeFieldEnd()
3431 rajveer 8393 
    if self.providerId is not None:
3427 chandransh 8394 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
8395 
      oprot.writeI64(self.providerId)
8396 
      oprot.writeFieldEnd()
3431 rajveer 8397 
    if self.warehouseId is not None:
3427 chandransh 8398 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
8399 
      oprot.writeI64(self.warehouseId)
8400 
      oprot.writeFieldEnd()
3451 chandransh 8401 
    if self.cod is not None:
8402 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
8403 
      oprot.writeBool(self.cod)
8404 
      oprot.writeFieldEnd()
3427 chandransh 8405 
    oprot.writeFieldStop()
8406 
    oprot.writeStructEnd()
8407 
 
3431 rajveer 8408 
  def validate(self):
8409 
    return
8410 
 
8411 
 
3427 chandransh 8412 
  def __repr__(self):
8413 
    L = ['%s=%r' % (key, value)
8414 
      for key, value in self.__dict__.iteritems()]
8415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8416 
 
8417 
  def __eq__(self, other):
8418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8419 
 
8420 
  def __ne__(self, other):
8421 
    return not (self == other)
8422 
 
8423 
class getOrdersByShippingDate_result:
8424 
  """
8425 
  Attributes:
8426 
   - success
8427 
   - ex
8428 
  """
8429 
 
8430 
  thrift_spec = (
8431 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8432 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8433 
  )
8434 
 
8435 
  def __init__(self, success=None, ex=None,):
8436 
    self.success = success
8437 
    self.ex = ex
8438 
 
8439 
  def read(self, iprot):
8440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8442 
      return
8443 
    iprot.readStructBegin()
8444 
    while True:
8445 
      (fname, ftype, fid) = iprot.readFieldBegin()
8446 
      if ftype == TType.STOP:
8447 
        break
8448 
      if fid == 0:
8449 
        if ftype == TType.LIST:
8450 
          self.success = []
5031 varun.gupt 8451 
          (_etype122, _size119) = iprot.readListBegin()
8452 
          for _i123 in xrange(_size119):
8453 
            _elem124 = Order()
8454 
            _elem124.read(iprot)
8455 
            self.success.append(_elem124)
3427 chandransh 8456 
          iprot.readListEnd()
8457 
        else:
8458 
          iprot.skip(ftype)
8459 
      elif fid == 1:
8460 
        if ftype == TType.STRUCT:
8461 
          self.ex = TransactionServiceException()
8462 
          self.ex.read(iprot)
8463 
        else:
8464 
          iprot.skip(ftype)
8465 
      else:
8466 
        iprot.skip(ftype)
8467 
      iprot.readFieldEnd()
8468 
    iprot.readStructEnd()
8469 
 
8470 
  def write(self, oprot):
8471 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8472 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8473 
      return
8474 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 8475 
    if self.success is not None:
3427 chandransh 8476 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8477 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8478 
      for iter125 in self.success:
8479 
        iter125.write(oprot)
3427 chandransh 8480 
      oprot.writeListEnd()
8481 
      oprot.writeFieldEnd()
3431 rajveer 8482 
    if self.ex is not None:
3427 chandransh 8483 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8484 
      self.ex.write(oprot)
8485 
      oprot.writeFieldEnd()
8486 
    oprot.writeFieldStop()
8487 
    oprot.writeStructEnd()
8488 
 
3431 rajveer 8489 
  def validate(self):
8490 
    return
8491 
 
8492 
 
3427 chandransh 8493 
  def __repr__(self):
8494 
    L = ['%s=%r' % (key, value)
8495 
      for key, value in self.__dict__.iteritems()]
8496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8497 
 
8498 
  def __eq__(self, other):
8499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8500 
 
8501 
  def __ne__(self, other):
8502 
    return not (self == other)
8503 
 
1382 varun.gupt 8504 
class getReturnableOrdersForCustomer_args:
8505 
  """
8506 
  Attributes:
8507 
   - customer_id
8508 
   - limit
8509 
  """
8510 
 
8511 
  thrift_spec = (
8512 
    None, # 0
8513 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8514 
    (2, TType.I64, 'limit', None, None, ), # 2
8515 
  )
8516 
 
8517 
  def __init__(self, customer_id=None, limit=None,):
8518 
    self.customer_id = customer_id
8519 
    self.limit = limit
8520 
 
8521 
  def read(self, iprot):
8522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8524 
      return
8525 
    iprot.readStructBegin()
8526 
    while True:
8527 
      (fname, ftype, fid) = iprot.readFieldBegin()
8528 
      if ftype == TType.STOP:
8529 
        break
8530 
      if fid == 1:
8531 
        if ftype == TType.I64:
8532 
          self.customer_id = iprot.readI64();
8533 
        else:
8534 
          iprot.skip(ftype)
8535 
      elif fid == 2:
8536 
        if ftype == TType.I64:
8537 
          self.limit = iprot.readI64();
8538 
        else:
8539 
          iprot.skip(ftype)
8540 
      else:
8541 
        iprot.skip(ftype)
8542 
      iprot.readFieldEnd()
8543 
    iprot.readStructEnd()
8544 
 
8545 
  def write(self, oprot):
8546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8548 
      return
8549 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 8550 
    if self.customer_id is not None:
1382 varun.gupt 8551 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8552 
      oprot.writeI64(self.customer_id)
8553 
      oprot.writeFieldEnd()
3431 rajveer 8554 
    if self.limit is not None:
1382 varun.gupt 8555 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8556 
      oprot.writeI64(self.limit)
8557 
      oprot.writeFieldEnd()
8558 
    oprot.writeFieldStop()
8559 
    oprot.writeStructEnd()
8560 
 
3431 rajveer 8561 
  def validate(self):
8562 
    return
8563 
 
8564 
 
1382 varun.gupt 8565 
  def __repr__(self):
8566 
    L = ['%s=%r' % (key, value)
8567 
      for key, value in self.__dict__.iteritems()]
8568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8569 
 
8570 
  def __eq__(self, other):
8571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8572 
 
8573 
  def __ne__(self, other):
8574 
    return not (self == other)
8575 
 
8576 
class getReturnableOrdersForCustomer_result:
8577 
  """
8578 
  Attributes:
8579 
   - success
8580 
   - ex
8581 
  """
8582 
 
8583 
  thrift_spec = (
8584 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8585 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8586 
  )
8587 
 
8588 
  def __init__(self, success=None, ex=None,):
8589 
    self.success = success
8590 
    self.ex = ex
8591 
 
8592 
  def read(self, iprot):
8593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8595 
      return
8596 
    iprot.readStructBegin()
8597 
    while True:
8598 
      (fname, ftype, fid) = iprot.readFieldBegin()
8599 
      if ftype == TType.STOP:
8600 
        break
8601 
      if fid == 0:
8602 
        if ftype == TType.LIST:
8603 
          self.success = []
5031 varun.gupt 8604 
          (_etype129, _size126) = iprot.readListBegin()
8605 
          for _i130 in xrange(_size126):
8606 
            _elem131 = iprot.readI64();
8607 
            self.success.append(_elem131)
1382 varun.gupt 8608 
          iprot.readListEnd()
8609 
        else:
8610 
          iprot.skip(ftype)
8611 
      elif fid == 1:
8612 
        if ftype == TType.STRUCT:
8613 
          self.ex = TransactionServiceException()
8614 
          self.ex.read(iprot)
8615 
        else:
8616 
          iprot.skip(ftype)
8617 
      else:
8618 
        iprot.skip(ftype)
8619 
      iprot.readFieldEnd()
8620 
    iprot.readStructEnd()
8621 
 
8622 
  def write(self, oprot):
8623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8625 
      return
8626 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 8627 
    if self.success is not None:
1382 varun.gupt 8628 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8629 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8630 
      for iter132 in self.success:
8631 
        oprot.writeI64(iter132)
1382 varun.gupt 8632 
      oprot.writeListEnd()
8633 
      oprot.writeFieldEnd()
3431 rajveer 8634 
    if self.ex is not None:
1382 varun.gupt 8635 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8636 
      self.ex.write(oprot)
8637 
      oprot.writeFieldEnd()
8638 
    oprot.writeFieldStop()
8639 
    oprot.writeStructEnd()
8640 
 
3431 rajveer 8641 
  def validate(self):
8642 
    return
8643 
 
8644 
 
1382 varun.gupt 8645 
  def __repr__(self):
8646 
    L = ['%s=%r' % (key, value)
8647 
      for key, value in self.__dict__.iteritems()]
8648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8649 
 
8650 
  def __eq__(self, other):
8651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8652 
 
8653 
  def __ne__(self, other):
8654 
    return not (self == other)
8655 
 
8656 
class getCancellableOrdersForCustomer_args:
8657 
  """
8658 
  Attributes:
8659 
   - customer_id
8660 
   - limit
8661 
  """
8662 
 
8663 
  thrift_spec = (
8664 
    None, # 0
8665 
    (1, TType.I64, 'customer_id', None, None, ), # 1
8666 
    (2, TType.I64, 'limit', None, None, ), # 2
8667 
  )
8668 
 
8669 
  def __init__(self, customer_id=None, limit=None,):
8670 
    self.customer_id = customer_id
8671 
    self.limit = limit
8672 
 
8673 
  def read(self, iprot):
8674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8676 
      return
8677 
    iprot.readStructBegin()
8678 
    while True:
8679 
      (fname, ftype, fid) = iprot.readFieldBegin()
8680 
      if ftype == TType.STOP:
8681 
        break
8682 
      if fid == 1:
8683 
        if ftype == TType.I64:
8684 
          self.customer_id = iprot.readI64();
8685 
        else:
8686 
          iprot.skip(ftype)
8687 
      elif fid == 2:
8688 
        if ftype == TType.I64:
8689 
          self.limit = iprot.readI64();
8690 
        else:
8691 
          iprot.skip(ftype)
8692 
      else:
8693 
        iprot.skip(ftype)
8694 
      iprot.readFieldEnd()
8695 
    iprot.readStructEnd()
8696 
 
8697 
  def write(self, oprot):
8698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8700 
      return
8701 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 8702 
    if self.customer_id is not None:
1382 varun.gupt 8703 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
8704 
      oprot.writeI64(self.customer_id)
8705 
      oprot.writeFieldEnd()
3431 rajveer 8706 
    if self.limit is not None:
1382 varun.gupt 8707 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8708 
      oprot.writeI64(self.limit)
8709 
      oprot.writeFieldEnd()
8710 
    oprot.writeFieldStop()
8711 
    oprot.writeStructEnd()
8712 
 
3431 rajveer 8713 
  def validate(self):
8714 
    return
8715 
 
8716 
 
1382 varun.gupt 8717 
  def __repr__(self):
8718 
    L = ['%s=%r' % (key, value)
8719 
      for key, value in self.__dict__.iteritems()]
8720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8721 
 
8722 
  def __eq__(self, other):
8723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8724 
 
8725 
  def __ne__(self, other):
8726 
    return not (self == other)
8727 
 
8728 
class getCancellableOrdersForCustomer_result:
8729 
  """
8730 
  Attributes:
8731 
   - success
8732 
   - ex
8733 
  """
8734 
 
8735 
  thrift_spec = (
8736 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8737 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8738 
  )
8739 
 
8740 
  def __init__(self, success=None, ex=None,):
8741 
    self.success = success
8742 
    self.ex = ex
8743 
 
8744 
  def read(self, iprot):
8745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8747 
      return
8748 
    iprot.readStructBegin()
8749 
    while True:
8750 
      (fname, ftype, fid) = iprot.readFieldBegin()
8751 
      if ftype == TType.STOP:
8752 
        break
8753 
      if fid == 0:
8754 
        if ftype == TType.LIST:
8755 
          self.success = []
5031 varun.gupt 8756 
          (_etype136, _size133) = iprot.readListBegin()
8757 
          for _i137 in xrange(_size133):
8758 
            _elem138 = iprot.readI64();
8759 
            self.success.append(_elem138)
1382 varun.gupt 8760 
          iprot.readListEnd()
8761 
        else:
8762 
          iprot.skip(ftype)
8763 
      elif fid == 1:
8764 
        if ftype == TType.STRUCT:
8765 
          self.ex = TransactionServiceException()
8766 
          self.ex.read(iprot)
8767 
        else:
8768 
          iprot.skip(ftype)
8769 
      else:
8770 
        iprot.skip(ftype)
8771 
      iprot.readFieldEnd()
8772 
    iprot.readStructEnd()
8773 
 
8774 
  def write(self, oprot):
8775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8777 
      return
8778 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 8779 
    if self.success is not None:
1382 varun.gupt 8780 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8781 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 8782 
      for iter139 in self.success:
8783 
        oprot.writeI64(iter139)
1382 varun.gupt 8784 
      oprot.writeListEnd()
8785 
      oprot.writeFieldEnd()
3431 rajveer 8786 
    if self.ex is not None:
1382 varun.gupt 8787 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8788 
      self.ex.write(oprot)
8789 
      oprot.writeFieldEnd()
8790 
    oprot.writeFieldStop()
8791 
    oprot.writeStructEnd()
8792 
 
3431 rajveer 8793 
  def validate(self):
8794 
    return
8795 
 
8796 
 
1382 varun.gupt 8797 
  def __repr__(self):
8798 
    L = ['%s=%r' % (key, value)
8799 
      for key, value in self.__dict__.iteritems()]
8800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8801 
 
8802 
  def __eq__(self, other):
8803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8804 
 
8805 
  def __ne__(self, other):
8806 
    return not (self == other)
8807 
 
483 rajveer 8808 
class changeOrderStatus_args:
94 ashish 8809 
  """
8810 
  Attributes:
483 rajveer 8811 
   - orderId
8812 
   - status
8813 
   - description
94 ashish 8814 
  """
8815 
 
8816 
  thrift_spec = (
8817 
    None, # 0
483 rajveer 8818 
    (1, TType.I64, 'orderId', None, None, ), # 1
8819 
    (2, TType.I32, 'status', None, None, ), # 2
8820 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 8821 
  )
8822 
 
483 rajveer 8823 
  def __init__(self, orderId=None, status=None, description=None,):
8824 
    self.orderId = orderId
8825 
    self.status = status
8826 
    self.description = description
94 ashish 8827 
 
8828 
  def read(self, iprot):
8829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8831 
      return
8832 
    iprot.readStructBegin()
8833 
    while True:
8834 
      (fname, ftype, fid) = iprot.readFieldBegin()
8835 
      if ftype == TType.STOP:
8836 
        break
8837 
      if fid == 1:
8838 
        if ftype == TType.I64:
483 rajveer 8839 
          self.orderId = iprot.readI64();
94 ashish 8840 
        else:
8841 
          iprot.skip(ftype)
8842 
      elif fid == 2:
483 rajveer 8843 
        if ftype == TType.I32:
8844 
          self.status = iprot.readI32();
94 ashish 8845 
        else:
8846 
          iprot.skip(ftype)
483 rajveer 8847 
      elif fid == 3:
8848 
        if ftype == TType.STRING:
8849 
          self.description = iprot.readString();
8850 
        else:
8851 
          iprot.skip(ftype)
94 ashish 8852 
      else:
8853 
        iprot.skip(ftype)
8854 
      iprot.readFieldEnd()
8855 
    iprot.readStructEnd()
8856 
 
8857 
  def write(self, oprot):
8858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8860 
      return
483 rajveer 8861 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 8862 
    if self.orderId is not None:
483 rajveer 8863 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8864 
      oprot.writeI64(self.orderId)
94 ashish 8865 
      oprot.writeFieldEnd()
3431 rajveer 8866 
    if self.status is not None:
483 rajveer 8867 
      oprot.writeFieldBegin('status', TType.I32, 2)
8868 
      oprot.writeI32(self.status)
94 ashish 8869 
      oprot.writeFieldEnd()
3431 rajveer 8870 
    if self.description is not None:
483 rajveer 8871 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8872 
      oprot.writeString(self.description)
8873 
      oprot.writeFieldEnd()
94 ashish 8874 
    oprot.writeFieldStop()
8875 
    oprot.writeStructEnd()
8876 
 
3431 rajveer 8877 
  def validate(self):
8878 
    return
8879 
 
8880 
 
94 ashish 8881 
  def __repr__(self):
8882 
    L = ['%s=%r' % (key, value)
8883 
      for key, value in self.__dict__.iteritems()]
8884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8885 
 
8886 
  def __eq__(self, other):
8887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8888 
 
8889 
  def __ne__(self, other):
8890 
    return not (self == other)
8891 
 
483 rajveer 8892 
class changeOrderStatus_result:
94 ashish 8893 
  """
8894 
  Attributes:
8895 
   - success
8896 
   - ex
8897 
  """
8898 
 
8899 
  thrift_spec = (
8900 
    (0, TType.BOOL, 'success', None, None, ), # 0
8901 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8902 
  )
8903 
 
8904 
  def __init__(self, success=None, ex=None,):
8905 
    self.success = success
8906 
    self.ex = ex
8907 
 
8908 
  def read(self, iprot):
8909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8911 
      return
8912 
    iprot.readStructBegin()
8913 
    while True:
8914 
      (fname, ftype, fid) = iprot.readFieldBegin()
8915 
      if ftype == TType.STOP:
8916 
        break
8917 
      if fid == 0:
8918 
        if ftype == TType.BOOL:
8919 
          self.success = iprot.readBool();
8920 
        else:
8921 
          iprot.skip(ftype)
8922 
      elif fid == 1:
8923 
        if ftype == TType.STRUCT:
8924 
          self.ex = TransactionServiceException()
8925 
          self.ex.read(iprot)
8926 
        else:
8927 
          iprot.skip(ftype)
8928 
      else:
8929 
        iprot.skip(ftype)
8930 
      iprot.readFieldEnd()
8931 
    iprot.readStructEnd()
8932 
 
8933 
  def write(self, oprot):
8934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8936 
      return
483 rajveer 8937 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 8938 
    if self.success is not None:
94 ashish 8939 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8940 
      oprot.writeBool(self.success)
8941 
      oprot.writeFieldEnd()
3431 rajveer 8942 
    if self.ex is not None:
94 ashish 8943 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8944 
      self.ex.write(oprot)
8945 
      oprot.writeFieldEnd()
8946 
    oprot.writeFieldStop()
8947 
    oprot.writeStructEnd()
8948 
 
3431 rajveer 8949 
  def validate(self):
8950 
    return
8951 
 
8952 
 
94 ashish 8953 
  def __repr__(self):
8954 
    L = ['%s=%r' % (key, value)
8955 
      for key, value in self.__dict__.iteritems()]
8956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8957 
 
8958 
  def __eq__(self, other):
8959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8960 
 
8961 
  def __ne__(self, other):
8962 
    return not (self == other)
8963 
 
3064 chandransh 8964 
class getOrdersForTransaction_args:
494 rajveer 8965 
  """
8966 
  Attributes:
3064 chandransh 8967 
   - transactionId
8968 
   - customerId
494 rajveer 8969 
  """
8970 
 
8971 
  thrift_spec = (
8972 
    None, # 0
3064 chandransh 8973 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8974 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 8975 
  )
8976 
 
3064 chandransh 8977 
  def __init__(self, transactionId=None, customerId=None,):
8978 
    self.transactionId = transactionId
8979 
    self.customerId = customerId
494 rajveer 8980 
 
8981 
  def read(self, iprot):
8982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8984 
      return
8985 
    iprot.readStructBegin()
8986 
    while True:
8987 
      (fname, ftype, fid) = iprot.readFieldBegin()
8988 
      if ftype == TType.STOP:
8989 
        break
8990 
      if fid == 1:
8991 
        if ftype == TType.I64:
3064 chandransh 8992 
          self.transactionId = iprot.readI64();
494 rajveer 8993 
        else:
8994 
          iprot.skip(ftype)
8995 
      elif fid == 2:
3064 chandransh 8996 
        if ftype == TType.I64:
8997 
          self.customerId = iprot.readI64();
494 rajveer 8998 
        else:
8999 
          iprot.skip(ftype)
9000 
      else:
9001 
        iprot.skip(ftype)
9002 
      iprot.readFieldEnd()
9003 
    iprot.readStructEnd()
9004 
 
9005 
  def write(self, oprot):
9006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9008 
      return
3064 chandransh 9009 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 9010 
    if self.transactionId is not None:
3064 chandransh 9011 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9012 
      oprot.writeI64(self.transactionId)
494 rajveer 9013 
      oprot.writeFieldEnd()
3431 rajveer 9014 
    if self.customerId is not None:
3064 chandransh 9015 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
9016 
      oprot.writeI64(self.customerId)
494 rajveer 9017 
      oprot.writeFieldEnd()
9018 
    oprot.writeFieldStop()
9019 
    oprot.writeStructEnd()
9020 
 
3431 rajveer 9021 
  def validate(self):
9022 
    return
9023 
 
9024 
 
494 rajveer 9025 
  def __repr__(self):
9026 
    L = ['%s=%r' % (key, value)
9027 
      for key, value in self.__dict__.iteritems()]
9028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9029 
 
9030 
  def __eq__(self, other):
9031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9032 
 
9033 
  def __ne__(self, other):
9034 
    return not (self == other)
9035 
 
3064 chandransh 9036 
class getOrdersForTransaction_result:
494 rajveer 9037 
  """
9038 
  Attributes:
9039 
   - success
9040 
   - ex
9041 
  """
9042 
 
9043 
  thrift_spec = (
3064 chandransh 9044 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 9045 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9046 
  )
9047 
 
9048 
  def __init__(self, success=None, ex=None,):
9049 
    self.success = success
9050 
    self.ex = ex
9051 
 
9052 
  def read(self, iprot):
9053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9055 
      return
9056 
    iprot.readStructBegin()
9057 
    while True:
9058 
      (fname, ftype, fid) = iprot.readFieldBegin()
9059 
      if ftype == TType.STOP:
9060 
        break
9061 
      if fid == 0:
3064 chandransh 9062 
        if ftype == TType.LIST:
9063 
          self.success = []
5031 varun.gupt 9064 
          (_etype143, _size140) = iprot.readListBegin()
9065 
          for _i144 in xrange(_size140):
9066 
            _elem145 = Order()
9067 
            _elem145.read(iprot)
9068 
            self.success.append(_elem145)
3064 chandransh 9069 
          iprot.readListEnd()
494 rajveer 9070 
        else:
9071 
          iprot.skip(ftype)
9072 
      elif fid == 1:
9073 
        if ftype == TType.STRUCT:
9074 
          self.ex = TransactionServiceException()
9075 
          self.ex.read(iprot)
9076 
        else:
9077 
          iprot.skip(ftype)
9078 
      else:
9079 
        iprot.skip(ftype)
9080 
      iprot.readFieldEnd()
9081 
    iprot.readStructEnd()
9082 
 
9083 
  def write(self, oprot):
9084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9086 
      return
3064 chandransh 9087 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 9088 
    if self.success is not None:
3064 chandransh 9089 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9090 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9091 
      for iter146 in self.success:
9092 
        iter146.write(oprot)
3064 chandransh 9093 
      oprot.writeListEnd()
494 rajveer 9094 
      oprot.writeFieldEnd()
3431 rajveer 9095 
    if self.ex is not None:
494 rajveer 9096 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9097 
      self.ex.write(oprot)
9098 
      oprot.writeFieldEnd()
9099 
    oprot.writeFieldStop()
9100 
    oprot.writeStructEnd()
9101 
 
3431 rajveer 9102 
  def validate(self):
9103 
    return
9104 
 
9105 
 
494 rajveer 9106 
  def __repr__(self):
9107 
    L = ['%s=%r' % (key, value)
9108 
      for key, value in self.__dict__.iteritems()]
9109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9110 
 
9111 
  def __eq__(self, other):
9112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9113 
 
9114 
  def __ne__(self, other):
9115 
    return not (self == other)
9116 
 
3064 chandransh 9117 
class getOrdersForCustomer_args:
1149 chandransh 9118 
  """
9119 
  Attributes:
3064 chandransh 9120 
   - customerId
9121 
   - from_date
9122 
   - to_date
9123 
   - statuses
1149 chandransh 9124 
  """
9125 
 
9126 
  thrift_spec = (
9127 
    None, # 0
3064 chandransh 9128 
    (1, TType.I64, 'customerId', None, None, ), # 1
9129 
    (2, TType.I64, 'from_date', None, None, ), # 2
9130 
    (3, TType.I64, 'to_date', None, None, ), # 3
9131 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 9132 
  )
9133 
 
3064 chandransh 9134 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
9135 
    self.customerId = customerId
9136 
    self.from_date = from_date
9137 
    self.to_date = to_date
9138 
    self.statuses = statuses
1149 chandransh 9139 
 
9140 
  def read(self, iprot):
9141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9143 
      return
9144 
    iprot.readStructBegin()
9145 
    while True:
9146 
      (fname, ftype, fid) = iprot.readFieldBegin()
9147 
      if ftype == TType.STOP:
9148 
        break
9149 
      if fid == 1:
9150 
        if ftype == TType.I64:
3064 chandransh 9151 
          self.customerId = iprot.readI64();
1149 chandransh 9152 
        else:
9153 
          iprot.skip(ftype)
9154 
      elif fid == 2:
9155 
        if ftype == TType.I64:
3064 chandransh 9156 
          self.from_date = iprot.readI64();
1149 chandransh 9157 
        else:
9158 
          iprot.skip(ftype)
2783 chandransh 9159 
      elif fid == 3:
9160 
        if ftype == TType.I64:
3064 chandransh 9161 
          self.to_date = iprot.readI64();
2783 chandransh 9162 
        else:
9163 
          iprot.skip(ftype)
9164 
      elif fid == 4:
3064 chandransh 9165 
        if ftype == TType.LIST:
9166 
          self.statuses = []
5031 varun.gupt 9167 
          (_etype150, _size147) = iprot.readListBegin()
9168 
          for _i151 in xrange(_size147):
9169 
            _elem152 = iprot.readI32();
9170 
            self.statuses.append(_elem152)
3064 chandransh 9171 
          iprot.readListEnd()
2783 chandransh 9172 
        else:
9173 
          iprot.skip(ftype)
1149 chandransh 9174 
      else:
9175 
        iprot.skip(ftype)
9176 
      iprot.readFieldEnd()
9177 
    iprot.readStructEnd()
9178 
 
9179 
  def write(self, oprot):
9180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9182 
      return
3064 chandransh 9183 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 9184 
    if self.customerId is not None:
3064 chandransh 9185 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9186 
      oprot.writeI64(self.customerId)
1149 chandransh 9187 
      oprot.writeFieldEnd()
3431 rajveer 9188 
    if self.from_date is not None:
3064 chandransh 9189 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9190 
      oprot.writeI64(self.from_date)
1149 chandransh 9191 
      oprot.writeFieldEnd()
3431 rajveer 9192 
    if self.to_date is not None:
3064 chandransh 9193 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9194 
      oprot.writeI64(self.to_date)
2783 chandransh 9195 
      oprot.writeFieldEnd()
3431 rajveer 9196 
    if self.statuses is not None:
3064 chandransh 9197 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
9198 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 9199 
      for iter153 in self.statuses:
9200 
        oprot.writeI32(iter153)
3064 chandransh 9201 
      oprot.writeListEnd()
2783 chandransh 9202 
      oprot.writeFieldEnd()
1149 chandransh 9203 
    oprot.writeFieldStop()
9204 
    oprot.writeStructEnd()
9205 
 
3431 rajveer 9206 
  def validate(self):
9207 
    return
9208 
 
9209 
 
1149 chandransh 9210 
  def __repr__(self):
9211 
    L = ['%s=%r' % (key, value)
9212 
      for key, value in self.__dict__.iteritems()]
9213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9214 
 
9215 
  def __eq__(self, other):
9216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9217 
 
9218 
  def __ne__(self, other):
9219 
    return not (self == other)
9220 
 
3064 chandransh 9221 
class getOrdersForCustomer_result:
1149 chandransh 9222 
  """
9223 
  Attributes:
9224 
   - success
9225 
   - ex
9226 
  """
9227 
 
9228 
  thrift_spec = (
3064 chandransh 9229 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 9230 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9231 
  )
9232 
 
9233 
  def __init__(self, success=None, ex=None,):
9234 
    self.success = success
9235 
    self.ex = ex
9236 
 
9237 
  def read(self, iprot):
9238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9240 
      return
9241 
    iprot.readStructBegin()
9242 
    while True:
9243 
      (fname, ftype, fid) = iprot.readFieldBegin()
9244 
      if ftype == TType.STOP:
9245 
        break
9246 
      if fid == 0:
3064 chandransh 9247 
        if ftype == TType.LIST:
9248 
          self.success = []
5031 varun.gupt 9249 
          (_etype157, _size154) = iprot.readListBegin()
9250 
          for _i158 in xrange(_size154):
9251 
            _elem159 = Order()
9252 
            _elem159.read(iprot)
9253 
            self.success.append(_elem159)
3064 chandransh 9254 
          iprot.readListEnd()
1149 chandransh 9255 
        else:
9256 
          iprot.skip(ftype)
9257 
      elif fid == 1:
9258 
        if ftype == TType.STRUCT:
9259 
          self.ex = TransactionServiceException()
9260 
          self.ex.read(iprot)
9261 
        else:
9262 
          iprot.skip(ftype)
9263 
      else:
9264 
        iprot.skip(ftype)
9265 
      iprot.readFieldEnd()
9266 
    iprot.readStructEnd()
9267 
 
9268 
  def write(self, oprot):
9269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9271 
      return
3064 chandransh 9272 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 9273 
    if self.success is not None:
3064 chandransh 9274 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9275 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9276 
      for iter160 in self.success:
9277 
        iter160.write(oprot)
3064 chandransh 9278 
      oprot.writeListEnd()
1149 chandransh 9279 
      oprot.writeFieldEnd()
3431 rajveer 9280 
    if self.ex is not None:
1149 chandransh 9281 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9282 
      self.ex.write(oprot)
9283 
      oprot.writeFieldEnd()
9284 
    oprot.writeFieldStop()
9285 
    oprot.writeStructEnd()
9286 
 
3431 rajveer 9287 
  def validate(self):
9288 
    return
9289 
 
9290 
 
1149 chandransh 9291 
  def __repr__(self):
9292 
    L = ['%s=%r' % (key, value)
9293 
      for key, value in self.__dict__.iteritems()]
9294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9295 
 
9296 
  def __eq__(self, other):
9297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9298 
 
9299 
  def __ne__(self, other):
9300 
    return not (self == other)
9301 
 
3064 chandransh 9302 
class createOrder_args:
921 rajveer 9303 
  """
9304 
  Attributes:
3064 chandransh 9305 
   - order
921 rajveer 9306 
  """
9307 
 
9308 
  thrift_spec = (
9309 
    None, # 0
3064 chandransh 9310 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 9311 
  )
9312 
 
3064 chandransh 9313 
  def __init__(self, order=None,):
9314 
    self.order = order
921 rajveer 9315 
 
9316 
  def read(self, iprot):
9317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9319 
      return
9320 
    iprot.readStructBegin()
9321 
    while True:
9322 
      (fname, ftype, fid) = iprot.readFieldBegin()
9323 
      if ftype == TType.STOP:
9324 
        break
9325 
      if fid == 1:
3064 chandransh 9326 
        if ftype == TType.STRUCT:
9327 
          self.order = Order()
9328 
          self.order.read(iprot)
921 rajveer 9329 
        else:
9330 
          iprot.skip(ftype)
9331 
      else:
9332 
        iprot.skip(ftype)
9333 
      iprot.readFieldEnd()
9334 
    iprot.readStructEnd()
9335 
 
9336 
  def write(self, oprot):
9337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9339 
      return
3064 chandransh 9340 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 9341 
    if self.order is not None:
3064 chandransh 9342 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
9343 
      self.order.write(oprot)
921 rajveer 9344 
      oprot.writeFieldEnd()
9345 
    oprot.writeFieldStop()
9346 
    oprot.writeStructEnd()
9347 
 
3431 rajveer 9348 
  def validate(self):
9349 
    return
9350 
 
9351 
 
921 rajveer 9352 
  def __repr__(self):
9353 
    L = ['%s=%r' % (key, value)
9354 
      for key, value in self.__dict__.iteritems()]
9355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9356 
 
9357 
  def __eq__(self, other):
9358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9359 
 
9360 
  def __ne__(self, other):
9361 
    return not (self == other)
9362 
 
3064 chandransh 9363 
class createOrder_result:
921 rajveer 9364 
  """
9365 
  Attributes:
9366 
   - success
9367 
   - ex
9368 
  """
9369 
 
9370 
  thrift_spec = (
3064 chandransh 9371 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 9372 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9373 
  )
9374 
 
9375 
  def __init__(self, success=None, ex=None,):
9376 
    self.success = success
9377 
    self.ex = ex
9378 
 
9379 
  def read(self, iprot):
9380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9382 
      return
9383 
    iprot.readStructBegin()
9384 
    while True:
9385 
      (fname, ftype, fid) = iprot.readFieldBegin()
9386 
      if ftype == TType.STOP:
9387 
        break
9388 
      if fid == 0:
3064 chandransh 9389 
        if ftype == TType.I64:
9390 
          self.success = iprot.readI64();
921 rajveer 9391 
        else:
9392 
          iprot.skip(ftype)
9393 
      elif fid == 1:
9394 
        if ftype == TType.STRUCT:
9395 
          self.ex = TransactionServiceException()
9396 
          self.ex.read(iprot)
9397 
        else:
9398 
          iprot.skip(ftype)
9399 
      else:
9400 
        iprot.skip(ftype)
9401 
      iprot.readFieldEnd()
9402 
    iprot.readStructEnd()
9403 
 
9404 
  def write(self, oprot):
9405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9407 
      return
3064 chandransh 9408 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 9409 
    if self.success is not None:
3064 chandransh 9410 
      oprot.writeFieldBegin('success', TType.I64, 0)
9411 
      oprot.writeI64(self.success)
921 rajveer 9412 
      oprot.writeFieldEnd()
3431 rajveer 9413 
    if self.ex is not None:
921 rajveer 9414 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9415 
      self.ex.write(oprot)
9416 
      oprot.writeFieldEnd()
9417 
    oprot.writeFieldStop()
9418 
    oprot.writeStructEnd()
9419 
 
3431 rajveer 9420 
  def validate(self):
9421 
    return
9422 
 
9423 
 
921 rajveer 9424 
  def __repr__(self):
9425 
    L = ['%s=%r' % (key, value)
9426 
      for key, value in self.__dict__.iteritems()]
9427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9428 
 
9429 
  def __eq__(self, other):
9430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9431 
 
9432 
  def __ne__(self, other):
9433 
    return not (self == other)
9434 
 
3064 chandransh 9435 
class getOrder_args:
921 rajveer 9436 
  """
9437 
  Attributes:
3064 chandransh 9438 
   - id
921 rajveer 9439 
  """
9440 
 
9441 
  thrift_spec = (
9442 
    None, # 0
3064 chandransh 9443 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 9444 
  )
9445 
 
3064 chandransh 9446 
  def __init__(self, id=None,):
9447 
    self.id = id
921 rajveer 9448 
 
9449 
  def read(self, iprot):
9450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9452 
      return
9453 
    iprot.readStructBegin()
9454 
    while True:
9455 
      (fname, ftype, fid) = iprot.readFieldBegin()
9456 
      if ftype == TType.STOP:
9457 
        break
9458 
      if fid == 1:
9459 
        if ftype == TType.I64:
3064 chandransh 9460 
          self.id = iprot.readI64();
921 rajveer 9461 
        else:
9462 
          iprot.skip(ftype)
9463 
      else:
9464 
        iprot.skip(ftype)
9465 
      iprot.readFieldEnd()
9466 
    iprot.readStructEnd()
9467 
 
9468 
  def write(self, oprot):
9469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9471 
      return
3064 chandransh 9472 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 9473 
    if self.id is not None:
3064 chandransh 9474 
      oprot.writeFieldBegin('id', TType.I64, 1)
9475 
      oprot.writeI64(self.id)
921 rajveer 9476 
      oprot.writeFieldEnd()
9477 
    oprot.writeFieldStop()
9478 
    oprot.writeStructEnd()
9479 
 
3431 rajveer 9480 
  def validate(self):
9481 
    return
9482 
 
9483 
 
921 rajveer 9484 
  def __repr__(self):
9485 
    L = ['%s=%r' % (key, value)
9486 
      for key, value in self.__dict__.iteritems()]
9487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9488 
 
9489 
  def __eq__(self, other):
9490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9491 
 
9492 
  def __ne__(self, other):
9493 
    return not (self == other)
9494 
 
3064 chandransh 9495 
class getOrder_result:
921 rajveer 9496 
  """
9497 
  Attributes:
9498 
   - success
9499 
   - ex
9500 
  """
9501 
 
9502 
  thrift_spec = (
3064 chandransh 9503 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 9504 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9505 
  )
9506 
 
9507 
  def __init__(self, success=None, ex=None,):
9508 
    self.success = success
9509 
    self.ex = ex
9510 
 
9511 
  def read(self, iprot):
9512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9514 
      return
9515 
    iprot.readStructBegin()
9516 
    while True:
9517 
      (fname, ftype, fid) = iprot.readFieldBegin()
9518 
      if ftype == TType.STOP:
9519 
        break
9520 
      if fid == 0:
3064 chandransh 9521 
        if ftype == TType.STRUCT:
9522 
          self.success = Order()
9523 
          self.success.read(iprot)
921 rajveer 9524 
        else:
9525 
          iprot.skip(ftype)
9526 
      elif fid == 1:
9527 
        if ftype == TType.STRUCT:
9528 
          self.ex = TransactionServiceException()
9529 
          self.ex.read(iprot)
9530 
        else:
9531 
          iprot.skip(ftype)
9532 
      else:
9533 
        iprot.skip(ftype)
9534 
      iprot.readFieldEnd()
9535 
    iprot.readStructEnd()
9536 
 
9537 
  def write(self, oprot):
9538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9540 
      return
3064 chandransh 9541 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 9542 
    if self.success is not None:
3064 chandransh 9543 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9544 
      self.success.write(oprot)
921 rajveer 9545 
      oprot.writeFieldEnd()
3431 rajveer 9546 
    if self.ex is not None:
921 rajveer 9547 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9548 
      self.ex.write(oprot)
9549 
      oprot.writeFieldEnd()
9550 
    oprot.writeFieldStop()
9551 
    oprot.writeStructEnd()
9552 
 
3431 rajveer 9553 
  def validate(self):
9554 
    return
9555 
 
9556 
 
921 rajveer 9557 
  def __repr__(self):
9558 
    L = ['%s=%r' % (key, value)
9559 
      for key, value in self.__dict__.iteritems()]
9560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9561 
 
9562 
  def __eq__(self, other):
9563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9564 
 
9565 
  def __ne__(self, other):
9566 
    return not (self == other)
9567 
 
3064 chandransh 9568 
class getLineItemsForOrder_args:
94 ashish 9569 
  """
9570 
  Attributes:
3064 chandransh 9571 
   - orderId
94 ashish 9572 
  """
9573 
 
9574 
  thrift_spec = (
9575 
    None, # 0
3064 chandransh 9576 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 9577 
  )
9578 
 
3064 chandransh 9579 
  def __init__(self, orderId=None,):
9580 
    self.orderId = orderId
94 ashish 9581 
 
9582 
  def read(self, iprot):
9583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9585 
      return
9586 
    iprot.readStructBegin()
9587 
    while True:
9588 
      (fname, ftype, fid) = iprot.readFieldBegin()
9589 
      if ftype == TType.STOP:
9590 
        break
9591 
      if fid == 1:
9592 
        if ftype == TType.I64:
3064 chandransh 9593 
          self.orderId = iprot.readI64();
94 ashish 9594 
        else:
9595 
          iprot.skip(ftype)
9596 
      else:
9597 
        iprot.skip(ftype)
9598 
      iprot.readFieldEnd()
9599 
    iprot.readStructEnd()
9600 
 
9601 
  def write(self, oprot):
9602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9604 
      return
3064 chandransh 9605 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 9606 
    if self.orderId is not None:
3064 chandransh 9607 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9608 
      oprot.writeI64(self.orderId)
94 ashish 9609 
      oprot.writeFieldEnd()
9610 
    oprot.writeFieldStop()
9611 
    oprot.writeStructEnd()
9612 
 
3431 rajveer 9613 
  def validate(self):
9614 
    return
9615 
 
9616 
 
94 ashish 9617 
  def __repr__(self):
9618 
    L = ['%s=%r' % (key, value)
9619 
      for key, value in self.__dict__.iteritems()]
9620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9621 
 
9622 
  def __eq__(self, other):
9623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9624 
 
9625 
  def __ne__(self, other):
9626 
    return not (self == other)
9627 
 
3064 chandransh 9628 
class getLineItemsForOrder_result:
94 ashish 9629 
  """
9630 
  Attributes:
9631 
   - success
9632 
   - ex
9633 
  """
9634 
 
9635 
  thrift_spec = (
3064 chandransh 9636 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 9637 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9638 
  )
9639 
 
9640 
  def __init__(self, success=None, ex=None,):
9641 
    self.success = success
9642 
    self.ex = ex
9643 
 
9644 
  def read(self, iprot):
9645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9647 
      return
9648 
    iprot.readStructBegin()
9649 
    while True:
9650 
      (fname, ftype, fid) = iprot.readFieldBegin()
9651 
      if ftype == TType.STOP:
9652 
        break
9653 
      if fid == 0:
483 rajveer 9654 
        if ftype == TType.LIST:
9655 
          self.success = []
5031 varun.gupt 9656 
          (_etype164, _size161) = iprot.readListBegin()
9657 
          for _i165 in xrange(_size161):
9658 
            _elem166 = LineItem()
9659 
            _elem166.read(iprot)
9660 
            self.success.append(_elem166)
483 rajveer 9661 
          iprot.readListEnd()
94 ashish 9662 
        else:
9663 
          iprot.skip(ftype)
9664 
      elif fid == 1:
9665 
        if ftype == TType.STRUCT:
9666 
          self.ex = TransactionServiceException()
9667 
          self.ex.read(iprot)
9668 
        else:
9669 
          iprot.skip(ftype)
9670 
      else:
9671 
        iprot.skip(ftype)
9672 
      iprot.readFieldEnd()
9673 
    iprot.readStructEnd()
9674 
 
9675 
  def write(self, oprot):
9676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9678 
      return
3064 chandransh 9679 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 9680 
    if self.success is not None:
483 rajveer 9681 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9682 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9683 
      for iter167 in self.success:
9684 
        iter167.write(oprot)
483 rajveer 9685 
      oprot.writeListEnd()
94 ashish 9686 
      oprot.writeFieldEnd()
3431 rajveer 9687 
    if self.ex is not None:
94 ashish 9688 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9689 
      self.ex.write(oprot)
9690 
      oprot.writeFieldEnd()
9691 
    oprot.writeFieldStop()
9692 
    oprot.writeStructEnd()
9693 
 
3431 rajveer 9694 
  def validate(self):
9695 
    return
9696 
 
9697 
 
94 ashish 9698 
  def __repr__(self):
9699 
    L = ['%s=%r' % (key, value)
9700 
      for key, value in self.__dict__.iteritems()]
9701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9702 
 
9703 
  def __eq__(self, other):
9704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9705 
 
9706 
  def __ne__(self, other):
9707 
    return not (self == other)
9708 
 
4999 phani.kuma 9709 
class getOrderList_args:
9710 
  """
9711 
  Attributes:
9712 
   - order_ids
9713 
  """
9714 
 
9715 
  thrift_spec = (
9716 
    None, # 0
9717 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
9718 
  )
9719 
 
9720 
  def __init__(self, order_ids=None,):
9721 
    self.order_ids = order_ids
9722 
 
9723 
  def read(self, iprot):
9724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9726 
      return
9727 
    iprot.readStructBegin()
9728 
    while True:
9729 
      (fname, ftype, fid) = iprot.readFieldBegin()
9730 
      if ftype == TType.STOP:
9731 
        break
9732 
      if fid == 1:
9733 
        if ftype == TType.LIST:
9734 
          self.order_ids = []
5031 varun.gupt 9735 
          (_etype171, _size168) = iprot.readListBegin()
9736 
          for _i172 in xrange(_size168):
9737 
            _elem173 = iprot.readI64();
9738 
            self.order_ids.append(_elem173)
4999 phani.kuma 9739 
          iprot.readListEnd()
9740 
        else:
9741 
          iprot.skip(ftype)
9742 
      else:
9743 
        iprot.skip(ftype)
9744 
      iprot.readFieldEnd()
9745 
    iprot.readStructEnd()
9746 
 
9747 
  def write(self, oprot):
9748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9750 
      return
9751 
    oprot.writeStructBegin('getOrderList_args')
9752 
    if self.order_ids is not None:
9753 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
9754 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
5031 varun.gupt 9755 
      for iter174 in self.order_ids:
9756 
        oprot.writeI64(iter174)
4999 phani.kuma 9757 
      oprot.writeListEnd()
9758 
      oprot.writeFieldEnd()
9759 
    oprot.writeFieldStop()
9760 
    oprot.writeStructEnd()
9761 
 
9762 
  def validate(self):
9763 
    return
9764 
 
9765 
 
9766 
  def __repr__(self):
9767 
    L = ['%s=%r' % (key, value)
9768 
      for key, value in self.__dict__.iteritems()]
9769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9770 
 
9771 
  def __eq__(self, other):
9772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9773 
 
9774 
  def __ne__(self, other):
9775 
    return not (self == other)
9776 
 
9777 
class getOrderList_result:
9778 
  """
9779 
  Attributes:
9780 
   - success
9781 
  """
9782 
 
9783 
  thrift_spec = (
9784 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9785 
  )
9786 
 
9787 
  def __init__(self, success=None,):
9788 
    self.success = success
9789 
 
9790 
  def read(self, iprot):
9791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9793 
      return
9794 
    iprot.readStructBegin()
9795 
    while True:
9796 
      (fname, ftype, fid) = iprot.readFieldBegin()
9797 
      if ftype == TType.STOP:
9798 
        break
9799 
      if fid == 0:
9800 
        if ftype == TType.LIST:
9801 
          self.success = []
5031 varun.gupt 9802 
          (_etype178, _size175) = iprot.readListBegin()
9803 
          for _i179 in xrange(_size175):
9804 
            _elem180 = Order()
9805 
            _elem180.read(iprot)
9806 
            self.success.append(_elem180)
4999 phani.kuma 9807 
          iprot.readListEnd()
9808 
        else:
9809 
          iprot.skip(ftype)
9810 
      else:
9811 
        iprot.skip(ftype)
9812 
      iprot.readFieldEnd()
9813 
    iprot.readStructEnd()
9814 
 
9815 
  def write(self, oprot):
9816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9818 
      return
9819 
    oprot.writeStructBegin('getOrderList_result')
9820 
    if self.success is not None:
9821 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9822 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9823 
      for iter181 in self.success:
9824 
        iter181.write(oprot)
4999 phani.kuma 9825 
      oprot.writeListEnd()
9826 
      oprot.writeFieldEnd()
9827 
    oprot.writeFieldStop()
9828 
    oprot.writeStructEnd()
9829 
 
9830 
  def validate(self):
9831 
    return
9832 
 
9833 
 
9834 
  def __repr__(self):
9835 
    L = ['%s=%r' % (key, value)
9836 
      for key, value in self.__dict__.iteritems()]
9837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9838 
 
9839 
  def __eq__(self, other):
9840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9841 
 
9842 
  def __ne__(self, other):
9843 
    return not (self == other)
9844 
 
3064 chandransh 9845 
class getOrderForCustomer_args:
94 ashish 9846 
  """
9847 
  Attributes:
3064 chandransh 9848 
   - orderId
483 rajveer 9849 
   - customerId
94 ashish 9850 
  """
9851 
 
9852 
  thrift_spec = (
9853 
    None, # 0
3064 chandransh 9854 
    (1, TType.I64, 'orderId', None, None, ), # 1
9855 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 9856 
  )
9857 
 
3064 chandransh 9858 
  def __init__(self, orderId=None, customerId=None,):
9859 
    self.orderId = orderId
483 rajveer 9860 
    self.customerId = customerId
94 ashish 9861 
 
9862 
  def read(self, iprot):
9863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9865 
      return
9866 
    iprot.readStructBegin()
9867 
    while True:
9868 
      (fname, ftype, fid) = iprot.readFieldBegin()
9869 
      if ftype == TType.STOP:
9870 
        break
9871 
      if fid == 1:
9872 
        if ftype == TType.I64:
3064 chandransh 9873 
          self.orderId = iprot.readI64();
94 ashish 9874 
        else:
9875 
          iprot.skip(ftype)
9876 
      elif fid == 2:
9877 
        if ftype == TType.I64:
3064 chandransh 9878 
          self.customerId = iprot.readI64();
94 ashish 9879 
        else:
9880 
          iprot.skip(ftype)
9881 
      else:
9882 
        iprot.skip(ftype)
9883 
      iprot.readFieldEnd()
9884 
    iprot.readStructEnd()
9885 
 
9886 
  def write(self, oprot):
9887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9889 
      return
3064 chandransh 9890 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 9891 
    if self.orderId is not None:
3064 chandransh 9892 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9893 
      oprot.writeI64(self.orderId)
9894 
      oprot.writeFieldEnd()
3431 rajveer 9895 
    if self.customerId is not None:
3064 chandransh 9896 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 9897 
      oprot.writeI64(self.customerId)
94 ashish 9898 
      oprot.writeFieldEnd()
9899 
    oprot.writeFieldStop()
9900 
    oprot.writeStructEnd()
9901 
 
3431 rajveer 9902 
  def validate(self):
9903 
    return
9904 
 
9905 
 
94 ashish 9906 
  def __repr__(self):
9907 
    L = ['%s=%r' % (key, value)
9908 
      for key, value in self.__dict__.iteritems()]
9909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9910 
 
9911 
  def __eq__(self, other):
9912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9913 
 
9914 
  def __ne__(self, other):
9915 
    return not (self == other)
9916 
 
3064 chandransh 9917 
class getOrderForCustomer_result:
94 ashish 9918 
  """
9919 
  Attributes:
9920 
   - success
9921 
   - ex
9922 
  """
9923 
 
9924 
  thrift_spec = (
3064 chandransh 9925 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 9926 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9927 
  )
9928 
 
9929 
  def __init__(self, success=None, ex=None,):
9930 
    self.success = success
9931 
    self.ex = ex
9932 
 
9933 
  def read(self, iprot):
9934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9936 
      return
9937 
    iprot.readStructBegin()
9938 
    while True:
9939 
      (fname, ftype, fid) = iprot.readFieldBegin()
9940 
      if ftype == TType.STOP:
9941 
        break
9942 
      if fid == 0:
3064 chandransh 9943 
        if ftype == TType.STRUCT:
9944 
          self.success = Order()
9945 
          self.success.read(iprot)
94 ashish 9946 
        else:
9947 
          iprot.skip(ftype)
9948 
      elif fid == 1:
9949 
        if ftype == TType.STRUCT:
9950 
          self.ex = TransactionServiceException()
9951 
          self.ex.read(iprot)
9952 
        else:
9953 
          iprot.skip(ftype)
9954 
      else:
9955 
        iprot.skip(ftype)
9956 
      iprot.readFieldEnd()
9957 
    iprot.readStructEnd()
9958 
 
9959 
  def write(self, oprot):
9960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9962 
      return
3064 chandransh 9963 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 9964 
    if self.success is not None:
3064 chandransh 9965 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9966 
      self.success.write(oprot)
94 ashish 9967 
      oprot.writeFieldEnd()
3431 rajveer 9968 
    if self.ex is not None:
94 ashish 9969 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9970 
      self.ex.write(oprot)
9971 
      oprot.writeFieldEnd()
9972 
    oprot.writeFieldStop()
9973 
    oprot.writeStructEnd()
9974 
 
3431 rajveer 9975 
  def validate(self):
9976 
    return
9977 
 
9978 
 
94 ashish 9979 
  def __repr__(self):
9980 
    L = ['%s=%r' % (key, value)
9981 
      for key, value in self.__dict__.iteritems()]
9982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9983 
 
9984 
  def __eq__(self, other):
9985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9986 
 
9987 
  def __ne__(self, other):
9988 
    return not (self == other)
9989 
 
3064 chandransh 9990 
class getAlerts_args:
94 ashish 9991 
  """
9992 
  Attributes:
4394 rajveer 9993 
   - type
4444 rajveer 9994 
   - warehouseId
4394 rajveer 9995 
   - status
9996 
   - timestamp
94 ashish 9997 
  """
9998 
 
9999 
  thrift_spec = (
10000 
    None, # 0
4394 rajveer 10001 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10002 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10003 
    (3, TType.I64, 'status', None, None, ), # 3
10004 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 10005 
  )
10006 
 
4444 rajveer 10007 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 10008 
    self.type = type
4444 rajveer 10009 
    self.warehouseId = warehouseId
4394 rajveer 10010 
    self.status = status
10011 
    self.timestamp = timestamp
94 ashish 10012 
 
10013 
  def read(self, iprot):
10014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10016 
      return
10017 
    iprot.readStructBegin()
10018 
    while True:
10019 
      (fname, ftype, fid) = iprot.readFieldBegin()
10020 
      if ftype == TType.STOP:
10021 
        break
10022 
      if fid == 1:
3064 chandransh 10023 
        if ftype == TType.I64:
4394 rajveer 10024 
          self.type = iprot.readI64();
94 ashish 10025 
        else:
10026 
          iprot.skip(ftype)
3064 chandransh 10027 
      elif fid == 2:
4394 rajveer 10028 
        if ftype == TType.I64:
4444 rajveer 10029 
          self.warehouseId = iprot.readI64();
3064 chandransh 10030 
        else:
10031 
          iprot.skip(ftype)
4394 rajveer 10032 
      elif fid == 3:
10033 
        if ftype == TType.I64:
4444 rajveer 10034 
          self.status = iprot.readI64();
10035 
        else:
10036 
          iprot.skip(ftype)
10037 
      elif fid == 4:
10038 
        if ftype == TType.I64:
4394 rajveer 10039 
          self.timestamp = iprot.readI64();
10040 
        else:
10041 
          iprot.skip(ftype)
94 ashish 10042 
      else:
10043 
        iprot.skip(ftype)
10044 
      iprot.readFieldEnd()
10045 
    iprot.readStructEnd()
10046 
 
10047 
  def write(self, oprot):
10048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10050 
      return
3064 chandransh 10051 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 10052 
    if self.type is not None:
10053 
      oprot.writeFieldBegin('type', TType.I64, 1)
10054 
      oprot.writeI64(self.type)
94 ashish 10055 
      oprot.writeFieldEnd()
4444 rajveer 10056 
    if self.warehouseId is not None:
10057 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10058 
      oprot.writeI64(self.warehouseId)
10059 
      oprot.writeFieldEnd()
4394 rajveer 10060 
    if self.status is not None:
4444 rajveer 10061 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 10062 
      oprot.writeI64(self.status)
3064 chandransh 10063 
      oprot.writeFieldEnd()
4394 rajveer 10064 
    if self.timestamp is not None:
4444 rajveer 10065 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 10066 
      oprot.writeI64(self.timestamp)
10067 
      oprot.writeFieldEnd()
94 ashish 10068 
    oprot.writeFieldStop()
10069 
    oprot.writeStructEnd()
10070 
 
3431 rajveer 10071 
  def validate(self):
10072 
    return
10073 
 
10074 
 
94 ashish 10075 
  def __repr__(self):
10076 
    L = ['%s=%r' % (key, value)
10077 
      for key, value in self.__dict__.iteritems()]
10078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10079 
 
10080 
  def __eq__(self, other):
10081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10082 
 
10083 
  def __ne__(self, other):
10084 
    return not (self == other)
10085 
 
3064 chandransh 10086 
class getAlerts_result:
94 ashish 10087 
  """
10088 
  Attributes:
10089 
   - success
10090 
  """
10091 
 
10092 
  thrift_spec = (
3064 chandransh 10093 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 10094 
  )
10095 
 
3064 chandransh 10096 
  def __init__(self, success=None,):
94 ashish 10097 
    self.success = success
10098 
 
10099 
  def read(self, iprot):
10100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10102 
      return
10103 
    iprot.readStructBegin()
10104 
    while True:
10105 
      (fname, ftype, fid) = iprot.readFieldBegin()
10106 
      if ftype == TType.STOP:
10107 
        break
10108 
      if fid == 0:
3064 chandransh 10109 
        if ftype == TType.LIST:
10110 
          self.success = []
5031 varun.gupt 10111 
          (_etype185, _size182) = iprot.readListBegin()
10112 
          for _i186 in xrange(_size182):
10113 
            _elem187 = Alert()
10114 
            _elem187.read(iprot)
10115 
            self.success.append(_elem187)
3064 chandransh 10116 
          iprot.readListEnd()
94 ashish 10117 
        else:
10118 
          iprot.skip(ftype)
10119 
      else:
10120 
        iprot.skip(ftype)
10121 
      iprot.readFieldEnd()
10122 
    iprot.readStructEnd()
10123 
 
10124 
  def write(self, oprot):
10125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10127 
      return
3064 chandransh 10128 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 10129 
    if self.success is not None:
3064 chandransh 10130 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10131 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10132 
      for iter188 in self.success:
10133 
        iter188.write(oprot)
3064 chandransh 10134 
      oprot.writeListEnd()
94 ashish 10135 
      oprot.writeFieldEnd()
10136 
    oprot.writeFieldStop()
10137 
    oprot.writeStructEnd()
10138 
 
3431 rajveer 10139 
  def validate(self):
10140 
    return
10141 
 
10142 
 
94 ashish 10143 
  def __repr__(self):
10144 
    L = ['%s=%r' % (key, value)
10145 
      for key, value in self.__dict__.iteritems()]
10146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10147 
 
10148 
  def __eq__(self, other):
10149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10150 
 
10151 
  def __ne__(self, other):
10152 
    return not (self == other)
10153 
 
4394 rajveer 10154 
class addAlert_args:
94 ashish 10155 
  """
10156 
  Attributes:
3064 chandransh 10157 
   - type
4444 rajveer 10158 
   - warehouseId
4394 rajveer 10159 
   - description
94 ashish 10160 
  """
10161 
 
10162 
  thrift_spec = (
10163 
    None, # 0
4394 rajveer 10164 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10165 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10166 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10167 
  )
10168 
 
4444 rajveer 10169 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 10170 
    self.type = type
4444 rajveer 10171 
    self.warehouseId = warehouseId
4394 rajveer 10172 
    self.description = description
94 ashish 10173 
 
10174 
  def read(self, iprot):
10175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10177 
      return
10178 
    iprot.readStructBegin()
10179 
    while True:
10180 
      (fname, ftype, fid) = iprot.readFieldBegin()
10181 
      if ftype == TType.STOP:
10182 
        break
10183 
      if fid == 1:
10184 
        if ftype == TType.I64:
4394 rajveer 10185 
          self.type = iprot.readI64();
94 ashish 10186 
        else:
10187 
          iprot.skip(ftype)
3064 chandransh 10188 
      elif fid == 2:
4444 rajveer 10189 
        if ftype == TType.I64:
10190 
          self.warehouseId = iprot.readI64();
10191 
        else:
10192 
          iprot.skip(ftype)
10193 
      elif fid == 3:
3064 chandransh 10194 
        if ftype == TType.STRING:
4394 rajveer 10195 
          self.description = iprot.readString();
3064 chandransh 10196 
        else:
10197 
          iprot.skip(ftype)
94 ashish 10198 
      else:
10199 
        iprot.skip(ftype)
10200 
      iprot.readFieldEnd()
10201 
    iprot.readStructEnd()
10202 
 
10203 
  def write(self, oprot):
10204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10206 
      return
4394 rajveer 10207 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 10208 
    if self.type is not None:
4394 rajveer 10209 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 10210 
      oprot.writeI64(self.type)
10211 
      oprot.writeFieldEnd()
4444 rajveer 10212 
    if self.warehouseId is not None:
10213 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10214 
      oprot.writeI64(self.warehouseId)
10215 
      oprot.writeFieldEnd()
4394 rajveer 10216 
    if self.description is not None:
4444 rajveer 10217 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 10218 
      oprot.writeString(self.description)
3064 chandransh 10219 
      oprot.writeFieldEnd()
94 ashish 10220 
    oprot.writeFieldStop()
10221 
    oprot.writeStructEnd()
10222 
 
3431 rajveer 10223 
  def validate(self):
10224 
    return
10225 
 
10226 
 
94 ashish 10227 
  def __repr__(self):
10228 
    L = ['%s=%r' % (key, value)
10229 
      for key, value in self.__dict__.iteritems()]
10230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10231 
 
10232 
  def __eq__(self, other):
10233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10234 
 
10235 
  def __ne__(self, other):
10236 
    return not (self == other)
10237 
 
4394 rajveer 10238 
class addAlert_result:
3064 chandransh 10239 
 
10240 
  thrift_spec = (
10241 
  )
10242 
 
10243 
  def read(self, iprot):
10244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10246 
      return
10247 
    iprot.readStructBegin()
10248 
    while True:
10249 
      (fname, ftype, fid) = iprot.readFieldBegin()
10250 
      if ftype == TType.STOP:
10251 
        break
10252 
      else:
10253 
        iprot.skip(ftype)
10254 
      iprot.readFieldEnd()
10255 
    iprot.readStructEnd()
10256 
 
10257 
  def write(self, oprot):
10258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10260 
      return
4394 rajveer 10261 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 10262 
    oprot.writeFieldStop()
10263 
    oprot.writeStructEnd()
10264 
 
3431 rajveer 10265 
  def validate(self):
10266 
    return
10267 
 
10268 
 
3064 chandransh 10269 
  def __repr__(self):
10270 
    L = ['%s=%r' % (key, value)
10271 
      for key, value in self.__dict__.iteritems()]
10272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10273 
 
10274 
  def __eq__(self, other):
10275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10276 
 
10277 
  def __ne__(self, other):
10278 
    return not (self == other)
10279 
 
4444 rajveer 10280 
class markAlertsAsSeen_args:
10281 
  """
10282 
  Attributes:
10283 
   - warehouseId
10284 
  """
10285 
 
10286 
  thrift_spec = (
10287 
    None, # 0
10288 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10289 
  )
10290 
 
10291 
  def __init__(self, warehouseId=None,):
10292 
    self.warehouseId = warehouseId
10293 
 
10294 
  def read(self, iprot):
10295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10297 
      return
10298 
    iprot.readStructBegin()
10299 
    while True:
10300 
      (fname, ftype, fid) = iprot.readFieldBegin()
10301 
      if ftype == TType.STOP:
10302 
        break
10303 
      if fid == 1:
10304 
        if ftype == TType.I64:
10305 
          self.warehouseId = iprot.readI64();
10306 
        else:
10307 
          iprot.skip(ftype)
10308 
      else:
10309 
        iprot.skip(ftype)
10310 
      iprot.readFieldEnd()
10311 
    iprot.readStructEnd()
10312 
 
10313 
  def write(self, oprot):
10314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10316 
      return
10317 
    oprot.writeStructBegin('markAlertsAsSeen_args')
10318 
    if self.warehouseId is not None:
10319 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10320 
      oprot.writeI64(self.warehouseId)
10321 
      oprot.writeFieldEnd()
10322 
    oprot.writeFieldStop()
10323 
    oprot.writeStructEnd()
10324 
 
10325 
  def validate(self):
10326 
    return
10327 
 
10328 
 
10329 
  def __repr__(self):
10330 
    L = ['%s=%r' % (key, value)
10331 
      for key, value in self.__dict__.iteritems()]
10332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10333 
 
10334 
  def __eq__(self, other):
10335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10336 
 
10337 
  def __ne__(self, other):
10338 
    return not (self == other)
10339 
 
10340 
class markAlertsAsSeen_result:
10341 
 
10342 
  thrift_spec = (
10343 
  )
10344 
 
10345 
  def read(self, iprot):
10346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10348 
      return
10349 
    iprot.readStructBegin()
10350 
    while True:
10351 
      (fname, ftype, fid) = iprot.readFieldBegin()
10352 
      if ftype == TType.STOP:
10353 
        break
10354 
      else:
10355 
        iprot.skip(ftype)
10356 
      iprot.readFieldEnd()
10357 
    iprot.readStructEnd()
10358 
 
10359 
  def write(self, oprot):
10360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10362 
      return
10363 
    oprot.writeStructBegin('markAlertsAsSeen_result')
10364 
    oprot.writeFieldStop()
10365 
    oprot.writeStructEnd()
10366 
 
10367 
  def validate(self):
10368 
    return
10369 
 
10370 
 
10371 
  def __repr__(self):
10372 
    L = ['%s=%r' % (key, value)
10373 
      for key, value in self.__dict__.iteritems()]
10374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10375 
 
10376 
  def __eq__(self, other):
10377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10378 
 
10379 
  def __ne__(self, other):
10380 
    return not (self == other)
10381 
 
3064 chandransh 10382 
class getValidOrderCount_args:
10383 
 
10384 
  thrift_spec = (
10385 
  )
10386 
 
10387 
  def read(self, iprot):
10388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10390 
      return
10391 
    iprot.readStructBegin()
10392 
    while True:
10393 
      (fname, ftype, fid) = iprot.readFieldBegin()
10394 
      if ftype == TType.STOP:
10395 
        break
10396 
      else:
10397 
        iprot.skip(ftype)
10398 
      iprot.readFieldEnd()
10399 
    iprot.readStructEnd()
10400 
 
10401 
  def write(self, oprot):
10402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10404 
      return
10405 
    oprot.writeStructBegin('getValidOrderCount_args')
10406 
    oprot.writeFieldStop()
10407 
    oprot.writeStructEnd()
10408 
 
3431 rajveer 10409 
  def validate(self):
10410 
    return
10411 
 
10412 
 
3064 chandransh 10413 
  def __repr__(self):
10414 
    L = ['%s=%r' % (key, value)
10415 
      for key, value in self.__dict__.iteritems()]
10416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10417 
 
10418 
  def __eq__(self, other):
10419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10420 
 
10421 
  def __ne__(self, other):
10422 
    return not (self == other)
10423 
 
10424 
class getValidOrderCount_result:
94 ashish 10425 
  """
10426 
  Attributes:
10427 
   - success
10428 
  """
10429 
 
10430 
  thrift_spec = (
3064 chandransh 10431 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10432 
  )
10433 
 
3064 chandransh 10434 
  def __init__(self, success=None,):
94 ashish 10435 
    self.success = success
10436 
 
10437 
  def read(self, iprot):
10438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10440 
      return
10441 
    iprot.readStructBegin()
10442 
    while True:
10443 
      (fname, ftype, fid) = iprot.readFieldBegin()
10444 
      if ftype == TType.STOP:
10445 
        break
10446 
      if fid == 0:
3064 chandransh 10447 
        if ftype == TType.I64:
10448 
          self.success = iprot.readI64();
94 ashish 10449 
        else:
10450 
          iprot.skip(ftype)
10451 
      else:
10452 
        iprot.skip(ftype)
10453 
      iprot.readFieldEnd()
10454 
    iprot.readStructEnd()
10455 
 
10456 
  def write(self, oprot):
10457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10459 
      return
3064 chandransh 10460 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 10461 
    if self.success is not None:
3064 chandransh 10462 
      oprot.writeFieldBegin('success', TType.I64, 0)
10463 
      oprot.writeI64(self.success)
94 ashish 10464 
      oprot.writeFieldEnd()
10465 
    oprot.writeFieldStop()
10466 
    oprot.writeStructEnd()
10467 
 
3431 rajveer 10468 
  def validate(self):
10469 
    return
10470 
 
10471 
 
94 ashish 10472 
  def __repr__(self):
10473 
    L = ['%s=%r' % (key, value)
10474 
      for key, value in self.__dict__.iteritems()]
10475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10476 
 
10477 
  def __eq__(self, other):
10478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10479 
 
10480 
  def __ne__(self, other):
10481 
    return not (self == other)
10482 
 
3064 chandransh 10483 
class getNoOfCustomersWithSuccessfulTransaction_args:
10484 
 
10485 
  thrift_spec = (
10486 
  )
10487 
 
10488 
  def read(self, iprot):
10489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10491 
      return
10492 
    iprot.readStructBegin()
10493 
    while True:
10494 
      (fname, ftype, fid) = iprot.readFieldBegin()
10495 
      if ftype == TType.STOP:
10496 
        break
10497 
      else:
10498 
        iprot.skip(ftype)
10499 
      iprot.readFieldEnd()
10500 
    iprot.readStructEnd()
10501 
 
10502 
  def write(self, oprot):
10503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10505 
      return
10506 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
10507 
    oprot.writeFieldStop()
10508 
    oprot.writeStructEnd()
10509 
 
3431 rajveer 10510 
  def validate(self):
10511 
    return
10512 
 
10513 
 
3064 chandransh 10514 
  def __repr__(self):
10515 
    L = ['%s=%r' % (key, value)
10516 
      for key, value in self.__dict__.iteritems()]
10517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10518 
 
10519 
  def __eq__(self, other):
10520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10521 
 
10522 
  def __ne__(self, other):
10523 
    return not (self == other)
10524 
 
10525 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 10526 
  """
10527 
  Attributes:
3064 chandransh 10528 
   - success
94 ashish 10529 
  """
10530 
 
10531 
  thrift_spec = (
3064 chandransh 10532 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10533 
  )
10534 
 
3064 chandransh 10535 
  def __init__(self, success=None,):
10536 
    self.success = success
94 ashish 10537 
 
10538 
  def read(self, iprot):
10539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10541 
      return
10542 
    iprot.readStructBegin()
10543 
    while True:
10544 
      (fname, ftype, fid) = iprot.readFieldBegin()
10545 
      if ftype == TType.STOP:
10546 
        break
3064 chandransh 10547 
      if fid == 0:
94 ashish 10548 
        if ftype == TType.I64:
3064 chandransh 10549 
          self.success = iprot.readI64();
94 ashish 10550 
        else:
10551 
          iprot.skip(ftype)
10552 
      else:
10553 
        iprot.skip(ftype)
10554 
      iprot.readFieldEnd()
10555 
    iprot.readStructEnd()
10556 
 
10557 
  def write(self, oprot):
10558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10560 
      return
3064 chandransh 10561 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 10562 
    if self.success is not None:
3064 chandransh 10563 
      oprot.writeFieldBegin('success', TType.I64, 0)
10564 
      oprot.writeI64(self.success)
94 ashish 10565 
      oprot.writeFieldEnd()
10566 
    oprot.writeFieldStop()
10567 
    oprot.writeStructEnd()
10568 
 
3431 rajveer 10569 
  def validate(self):
10570 
    return
10571 
 
10572 
 
94 ashish 10573 
  def __repr__(self):
10574 
    L = ['%s=%r' % (key, value)
10575 
      for key, value in self.__dict__.iteritems()]
10576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10577 
 
10578 
  def __eq__(self, other):
10579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10580 
 
10581 
  def __ne__(self, other):
10582 
    return not (self == other)
10583 
 
3064 chandransh 10584 
class getValidOrdersAmountRange_args:
10585 
 
10586 
  thrift_spec = (
10587 
  )
10588 
 
10589 
  def read(self, iprot):
10590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10592 
      return
10593 
    iprot.readStructBegin()
10594 
    while True:
10595 
      (fname, ftype, fid) = iprot.readFieldBegin()
10596 
      if ftype == TType.STOP:
10597 
        break
10598 
      else:
10599 
        iprot.skip(ftype)
10600 
      iprot.readFieldEnd()
10601 
    iprot.readStructEnd()
10602 
 
10603 
  def write(self, oprot):
10604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10606 
      return
10607 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
10608 
    oprot.writeFieldStop()
10609 
    oprot.writeStructEnd()
10610 
 
3431 rajveer 10611 
  def validate(self):
10612 
    return
10613 
 
10614 
 
3064 chandransh 10615 
  def __repr__(self):
10616 
    L = ['%s=%r' % (key, value)
10617 
      for key, value in self.__dict__.iteritems()]
10618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10619 
 
10620 
  def __eq__(self, other):
10621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10622 
 
10623 
  def __ne__(self, other):
10624 
    return not (self == other)
10625 
 
10626 
class getValidOrdersAmountRange_result:
94 ashish 10627 
  """
10628 
  Attributes:
10629 
   - success
10630 
  """
10631 
 
10632 
  thrift_spec = (
3064 chandransh 10633 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 10634 
  )
10635 
 
3064 chandransh 10636 
  def __init__(self, success=None,):
94 ashish 10637 
    self.success = success
10638 
 
10639 
  def read(self, iprot):
10640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10642 
      return
10643 
    iprot.readStructBegin()
10644 
    while True:
10645 
      (fname, ftype, fid) = iprot.readFieldBegin()
10646 
      if ftype == TType.STOP:
10647 
        break
10648 
      if fid == 0:
483 rajveer 10649 
        if ftype == TType.LIST:
10650 
          self.success = []
5031 varun.gupt 10651 
          (_etype192, _size189) = iprot.readListBegin()
10652 
          for _i193 in xrange(_size189):
10653 
            _elem194 = iprot.readDouble();
10654 
            self.success.append(_elem194)
483 rajveer 10655 
          iprot.readListEnd()
94 ashish 10656 
        else:
10657 
          iprot.skip(ftype)
10658 
      else:
10659 
        iprot.skip(ftype)
10660 
      iprot.readFieldEnd()
10661 
    iprot.readStructEnd()
10662 
 
10663 
  def write(self, oprot):
10664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10666 
      return
3064 chandransh 10667 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 10668 
    if self.success is not None:
483 rajveer 10669 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 10670 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
5031 varun.gupt 10671 
      for iter195 in self.success:
10672 
        oprot.writeDouble(iter195)
483 rajveer 10673 
      oprot.writeListEnd()
94 ashish 10674 
      oprot.writeFieldEnd()
10675 
    oprot.writeFieldStop()
10676 
    oprot.writeStructEnd()
10677 
 
3431 rajveer 10678 
  def validate(self):
10679 
    return
10680 
 
10681 
 
94 ashish 10682 
  def __repr__(self):
10683 
    L = ['%s=%r' % (key, value)
10684 
      for key, value in self.__dict__.iteritems()]
10685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10686 
 
10687 
  def __eq__(self, other):
10688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10689 
 
10690 
  def __ne__(self, other):
10691 
    return not (self == other)
10692 
 
3064 chandransh 10693 
class getValidOrders_args:
1528 ankur.sing 10694 
  """
10695 
  Attributes:
3064 chandransh 10696 
   - limit
1528 ankur.sing 10697 
  """
10698 
 
10699 
  thrift_spec = (
10700 
    None, # 0
3064 chandransh 10701 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 10702 
  )
10703 
 
3064 chandransh 10704 
  def __init__(self, limit=None,):
10705 
    self.limit = limit
1528 ankur.sing 10706 
 
10707 
  def read(self, iprot):
10708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10710 
      return
10711 
    iprot.readStructBegin()
10712 
    while True:
10713 
      (fname, ftype, fid) = iprot.readFieldBegin()
10714 
      if ftype == TType.STOP:
10715 
        break
10716 
      if fid == 1:
10717 
        if ftype == TType.I64:
3064 chandransh 10718 
          self.limit = iprot.readI64();
1528 ankur.sing 10719 
        else:
10720 
          iprot.skip(ftype)
10721 
      else:
10722 
        iprot.skip(ftype)
10723 
      iprot.readFieldEnd()
10724 
    iprot.readStructEnd()
10725 
 
10726 
  def write(self, oprot):
10727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10729 
      return
3064 chandransh 10730 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 10731 
    if self.limit is not None:
3064 chandransh 10732 
      oprot.writeFieldBegin('limit', TType.I64, 1)
10733 
      oprot.writeI64(self.limit)
1528 ankur.sing 10734 
      oprot.writeFieldEnd()
10735 
    oprot.writeFieldStop()
10736 
    oprot.writeStructEnd()
10737 
 
3431 rajveer 10738 
  def validate(self):
10739 
    return
10740 
 
10741 
 
1528 ankur.sing 10742 
  def __repr__(self):
10743 
    L = ['%s=%r' % (key, value)
10744 
      for key, value in self.__dict__.iteritems()]
10745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10746 
 
10747 
  def __eq__(self, other):
10748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10749 
 
10750 
  def __ne__(self, other):
10751 
    return not (self == other)
10752 
 
3064 chandransh 10753 
class getValidOrders_result:
1528 ankur.sing 10754 
  """
10755 
  Attributes:
10756 
   - success
10757 
  """
10758 
 
10759 
  thrift_spec = (
3064 chandransh 10760 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 10761 
  )
10762 
 
3064 chandransh 10763 
  def __init__(self, success=None,):
1528 ankur.sing 10764 
    self.success = success
10765 
 
10766 
  def read(self, iprot):
10767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10769 
      return
10770 
    iprot.readStructBegin()
10771 
    while True:
10772 
      (fname, ftype, fid) = iprot.readFieldBegin()
10773 
      if ftype == TType.STOP:
10774 
        break
10775 
      if fid == 0:
3064 chandransh 10776 
        if ftype == TType.LIST:
10777 
          self.success = []
5031 varun.gupt 10778 
          (_etype199, _size196) = iprot.readListBegin()
10779 
          for _i200 in xrange(_size196):
10780 
            _elem201 = Order()
10781 
            _elem201.read(iprot)
10782 
            self.success.append(_elem201)
3064 chandransh 10783 
          iprot.readListEnd()
1528 ankur.sing 10784 
        else:
10785 
          iprot.skip(ftype)
10786 
      else:
10787 
        iprot.skip(ftype)
10788 
      iprot.readFieldEnd()
10789 
    iprot.readStructEnd()
10790 
 
10791 
  def write(self, oprot):
10792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10794 
      return
3064 chandransh 10795 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 10796 
    if self.success is not None:
3064 chandransh 10797 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10798 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10799 
      for iter202 in self.success:
10800 
        iter202.write(oprot)
3064 chandransh 10801 
      oprot.writeListEnd()
1528 ankur.sing 10802 
      oprot.writeFieldEnd()
10803 
    oprot.writeFieldStop()
10804 
    oprot.writeStructEnd()
10805 
 
3431 rajveer 10806 
  def validate(self):
10807 
    return
10808 
 
10809 
 
1528 ankur.sing 10810 
  def __repr__(self):
10811 
    L = ['%s=%r' % (key, value)
10812 
      for key, value in self.__dict__.iteritems()]
10813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10814 
 
10815 
  def __eq__(self, other):
10816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10817 
 
10818 
  def __ne__(self, other):
10819 
    return not (self == other)
10820 
 
1220 chandransh 10821 
class batchOrders_args:
10822 
  """
10823 
  Attributes:
10824 
   - warehouseId
10825 
  """
10826 
 
10827 
  thrift_spec = (
10828 
    None, # 0
10829 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
10830 
  )
10831 
 
10832 
  def __init__(self, warehouseId=None,):
10833 
    self.warehouseId = warehouseId
10834 
 
10835 
  def read(self, iprot):
10836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10838 
      return
10839 
    iprot.readStructBegin()
10840 
    while True:
10841 
      (fname, ftype, fid) = iprot.readFieldBegin()
10842 
      if ftype == TType.STOP:
10843 
        break
10844 
      if fid == 1:
10845 
        if ftype == TType.I64:
10846 
          self.warehouseId = iprot.readI64();
10847 
        else:
10848 
          iprot.skip(ftype)
10849 
      else:
10850 
        iprot.skip(ftype)
10851 
      iprot.readFieldEnd()
10852 
    iprot.readStructEnd()
10853 
 
10854 
  def write(self, oprot):
10855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10857 
      return
10858 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 10859 
    if self.warehouseId is not None:
1220 chandransh 10860 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
10861 
      oprot.writeI64(self.warehouseId)
10862 
      oprot.writeFieldEnd()
10863 
    oprot.writeFieldStop()
10864 
    oprot.writeStructEnd()
10865 
 
3431 rajveer 10866 
  def validate(self):
10867 
    return
10868 
 
10869 
 
1220 chandransh 10870 
  def __repr__(self):
10871 
    L = ['%s=%r' % (key, value)
10872 
      for key, value in self.__dict__.iteritems()]
10873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10874 
 
10875 
  def __eq__(self, other):
10876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10877 
 
10878 
  def __ne__(self, other):
10879 
    return not (self == other)
10880 
 
10881 
class batchOrders_result:
10882 
  """
10883 
  Attributes:
10884 
   - success
10885 
   - ex
10886 
  """
10887 
 
10888 
  thrift_spec = (
10889 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10890 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10891 
  )
10892 
 
10893 
  def __init__(self, success=None, ex=None,):
10894 
    self.success = success
10895 
    self.ex = ex
10896 
 
10897 
  def read(self, iprot):
10898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10900 
      return
10901 
    iprot.readStructBegin()
10902 
    while True:
10903 
      (fname, ftype, fid) = iprot.readFieldBegin()
10904 
      if ftype == TType.STOP:
10905 
        break
10906 
      if fid == 0:
10907 
        if ftype == TType.LIST:
10908 
          self.success = []
5031 varun.gupt 10909 
          (_etype206, _size203) = iprot.readListBegin()
10910 
          for _i207 in xrange(_size203):
10911 
            _elem208 = Order()
10912 
            _elem208.read(iprot)
10913 
            self.success.append(_elem208)
1220 chandransh 10914 
          iprot.readListEnd()
10915 
        else:
10916 
          iprot.skip(ftype)
10917 
      elif fid == 1:
10918 
        if ftype == TType.STRUCT:
10919 
          self.ex = TransactionServiceException()
10920 
          self.ex.read(iprot)
10921 
        else:
10922 
          iprot.skip(ftype)
10923 
      else:
10924 
        iprot.skip(ftype)
10925 
      iprot.readFieldEnd()
10926 
    iprot.readStructEnd()
10927 
 
10928 
  def write(self, oprot):
10929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10931 
      return
10932 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 10933 
    if self.success is not None:
1220 chandransh 10934 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10935 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10936 
      for iter209 in self.success:
10937 
        iter209.write(oprot)
1220 chandransh 10938 
      oprot.writeListEnd()
10939 
      oprot.writeFieldEnd()
3431 rajveer 10940 
    if self.ex is not None:
1220 chandransh 10941 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10942 
      self.ex.write(oprot)
10943 
      oprot.writeFieldEnd()
10944 
    oprot.writeFieldStop()
10945 
    oprot.writeStructEnd()
10946 
 
3431 rajveer 10947 
  def validate(self):
10948 
    return
10949 
 
10950 
 
1220 chandransh 10951 
  def __repr__(self):
10952 
    L = ['%s=%r' % (key, value)
10953 
      for key, value in self.__dict__.iteritems()]
10954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10955 
 
10956 
  def __eq__(self, other):
10957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10958 
 
10959 
  def __ne__(self, other):
10960 
    return not (self == other)
10961 
 
1208 chandransh 10962 
class markOrderAsOutOfStock_args:
10963 
  """
10964 
  Attributes:
10965 
   - orderId
10966 
  """
10967 
 
10968 
  thrift_spec = (
10969 
    None, # 0
10970 
    (1, TType.I64, 'orderId', None, None, ), # 1
10971 
  )
10972 
 
10973 
  def __init__(self, orderId=None,):
10974 
    self.orderId = orderId
10975 
 
10976 
  def read(self, iprot):
10977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10979 
      return
10980 
    iprot.readStructBegin()
10981 
    while True:
10982 
      (fname, ftype, fid) = iprot.readFieldBegin()
10983 
      if ftype == TType.STOP:
10984 
        break
10985 
      if fid == 1:
10986 
        if ftype == TType.I64:
10987 
          self.orderId = iprot.readI64();
10988 
        else:
10989 
          iprot.skip(ftype)
10990 
      else:
10991 
        iprot.skip(ftype)
10992 
      iprot.readFieldEnd()
10993 
    iprot.readStructEnd()
10994 
 
10995 
  def write(self, oprot):
10996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10998 
      return
10999 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 11000 
    if self.orderId is not None:
1208 chandransh 11001 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11002 
      oprot.writeI64(self.orderId)
11003 
      oprot.writeFieldEnd()
11004 
    oprot.writeFieldStop()
11005 
    oprot.writeStructEnd()
11006 
 
3431 rajveer 11007 
  def validate(self):
11008 
    return
11009 
 
11010 
 
1208 chandransh 11011 
  def __repr__(self):
11012 
    L = ['%s=%r' % (key, value)
11013 
      for key, value in self.__dict__.iteritems()]
11014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11015 
 
11016 
  def __eq__(self, other):
11017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11018 
 
11019 
  def __ne__(self, other):
11020 
    return not (self == other)
11021 
 
11022 
class markOrderAsOutOfStock_result:
11023 
  """
11024 
  Attributes:
11025 
   - success
11026 
   - ex
11027 
  """
11028 
 
11029 
  thrift_spec = (
11030 
    (0, TType.BOOL, 'success', None, None, ), # 0
11031 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11032 
  )
11033 
 
11034 
  def __init__(self, success=None, ex=None,):
11035 
    self.success = success
11036 
    self.ex = ex
11037 
 
11038 
  def read(self, iprot):
11039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11041 
      return
11042 
    iprot.readStructBegin()
11043 
    while True:
11044 
      (fname, ftype, fid) = iprot.readFieldBegin()
11045 
      if ftype == TType.STOP:
11046 
        break
11047 
      if fid == 0:
11048 
        if ftype == TType.BOOL:
11049 
          self.success = iprot.readBool();
11050 
        else:
11051 
          iprot.skip(ftype)
11052 
      elif fid == 1:
11053 
        if ftype == TType.STRUCT:
11054 
          self.ex = TransactionServiceException()
11055 
          self.ex.read(iprot)
11056 
        else:
11057 
          iprot.skip(ftype)
11058 
      else:
11059 
        iprot.skip(ftype)
11060 
      iprot.readFieldEnd()
11061 
    iprot.readStructEnd()
11062 
 
11063 
  def write(self, oprot):
11064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11066 
      return
11067 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 11068 
    if self.success is not None:
1208 chandransh 11069 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11070 
      oprot.writeBool(self.success)
11071 
      oprot.writeFieldEnd()
3431 rajveer 11072 
    if self.ex is not None:
1208 chandransh 11073 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11074 
      self.ex.write(oprot)
11075 
      oprot.writeFieldEnd()
11076 
    oprot.writeFieldStop()
11077 
    oprot.writeStructEnd()
11078 
 
3431 rajveer 11079 
  def validate(self):
11080 
    return
11081 
 
11082 
 
1208 chandransh 11083 
  def __repr__(self):
11084 
    L = ['%s=%r' % (key, value)
11085 
      for key, value in self.__dict__.iteritems()]
11086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11087 
 
11088 
  def __eq__(self, other):
11089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11090 
 
11091 
  def __ne__(self, other):
11092 
    return not (self == other)
11093 
 
3064 chandransh 11094 
class verifyOrder_args:
759 chandransh 11095 
  """
11096 
  Attributes:
3064 chandransh 11097 
   - orderId
759 chandransh 11098 
  """
11099 
 
11100 
  thrift_spec = (
11101 
    None, # 0
3064 chandransh 11102 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 11103 
  )
11104 
 
3064 chandransh 11105 
  def __init__(self, orderId=None,):
11106 
    self.orderId = orderId
759 chandransh 11107 
 
11108 
  def read(self, iprot):
11109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11111 
      return
11112 
    iprot.readStructBegin()
11113 
    while True:
11114 
      (fname, ftype, fid) = iprot.readFieldBegin()
11115 
      if ftype == TType.STOP:
11116 
        break
11117 
      if fid == 1:
11118 
        if ftype == TType.I64:
3064 chandransh 11119 
          self.orderId = iprot.readI64();
759 chandransh 11120 
        else:
11121 
          iprot.skip(ftype)
11122 
      else:
11123 
        iprot.skip(ftype)
11124 
      iprot.readFieldEnd()
11125 
    iprot.readStructEnd()
11126 
 
11127 
  def write(self, oprot):
11128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11130 
      return
3064 chandransh 11131 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 11132 
    if self.orderId is not None:
3064 chandransh 11133 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11134 
      oprot.writeI64(self.orderId)
759 chandransh 11135 
      oprot.writeFieldEnd()
11136 
    oprot.writeFieldStop()
11137 
    oprot.writeStructEnd()
11138 
 
3431 rajveer 11139 
  def validate(self):
11140 
    return
11141 
 
11142 
 
759 chandransh 11143 
  def __repr__(self):
11144 
    L = ['%s=%r' % (key, value)
11145 
      for key, value in self.__dict__.iteritems()]
11146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11147 
 
11148 
  def __eq__(self, other):
11149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11150 
 
11151 
  def __ne__(self, other):
11152 
    return not (self == other)
11153 
 
3064 chandransh 11154 
class verifyOrder_result:
759 chandransh 11155 
  """
11156 
  Attributes:
11157 
   - success
11158 
   - ex
11159 
  """
11160 
 
11161 
  thrift_spec = (
11162 
    (0, TType.BOOL, 'success', None, None, ), # 0
11163 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11164 
  )
11165 
 
11166 
  def __init__(self, success=None, ex=None,):
11167 
    self.success = success
11168 
    self.ex = ex
11169 
 
11170 
  def read(self, iprot):
11171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11173 
      return
11174 
    iprot.readStructBegin()
11175 
    while True:
11176 
      (fname, ftype, fid) = iprot.readFieldBegin()
11177 
      if ftype == TType.STOP:
11178 
        break
11179 
      if fid == 0:
11180 
        if ftype == TType.BOOL:
11181 
          self.success = iprot.readBool();
11182 
        else:
11183 
          iprot.skip(ftype)
11184 
      elif fid == 1:
11185 
        if ftype == TType.STRUCT:
11186 
          self.ex = TransactionServiceException()
11187 
          self.ex.read(iprot)
11188 
        else:
11189 
          iprot.skip(ftype)
11190 
      else:
11191 
        iprot.skip(ftype)
11192 
      iprot.readFieldEnd()
11193 
    iprot.readStructEnd()
11194 
 
11195 
  def write(self, oprot):
11196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11198 
      return
3064 chandransh 11199 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 11200 
    if self.success is not None:
759 chandransh 11201 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11202 
      oprot.writeBool(self.success)
11203 
      oprot.writeFieldEnd()
3431 rajveer 11204 
    if self.ex is not None:
759 chandransh 11205 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11206 
      self.ex.write(oprot)
11207 
      oprot.writeFieldEnd()
11208 
    oprot.writeFieldStop()
11209 
    oprot.writeStructEnd()
11210 
 
3431 rajveer 11211 
  def validate(self):
11212 
    return
11213 
 
11214 
 
759 chandransh 11215 
  def __repr__(self):
11216 
    L = ['%s=%r' % (key, value)
11217 
      for key, value in self.__dict__.iteritems()]
11218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11219 
 
11220 
  def __eq__(self, other):
11221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11222 
 
11223 
  def __ne__(self, other):
11224 
    return not (self == other)
11225 
 
3064 chandransh 11226 
class acceptOrder_args:
1113 chandransh 11227 
  """
11228 
  Attributes:
3064 chandransh 11229 
   - orderId
1113 chandransh 11230 
  """
11231 
 
11232 
  thrift_spec = (
11233 
    None, # 0
3064 chandransh 11234 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 11235 
  )
11236 
 
3064 chandransh 11237 
  def __init__(self, orderId=None,):
11238 
    self.orderId = orderId
1113 chandransh 11239 
 
11240 
  def read(self, iprot):
11241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11243 
      return
11244 
    iprot.readStructBegin()
11245 
    while True:
11246 
      (fname, ftype, fid) = iprot.readFieldBegin()
11247 
      if ftype == TType.STOP:
11248 
        break
11249 
      if fid == 1:
11250 
        if ftype == TType.I64:
3064 chandransh 11251 
          self.orderId = iprot.readI64();
1113 chandransh 11252 
        else:
11253 
          iprot.skip(ftype)
11254 
      else:
11255 
        iprot.skip(ftype)
11256 
      iprot.readFieldEnd()
11257 
    iprot.readStructEnd()
11258 
 
11259 
  def write(self, oprot):
11260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11262 
      return
3064 chandransh 11263 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 11264 
    if self.orderId is not None:
3064 chandransh 11265 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11266 
      oprot.writeI64(self.orderId)
1113 chandransh 11267 
      oprot.writeFieldEnd()
11268 
    oprot.writeFieldStop()
11269 
    oprot.writeStructEnd()
11270 
 
3431 rajveer 11271 
  def validate(self):
11272 
    return
11273 
 
11274 
 
1113 chandransh 11275 
  def __repr__(self):
11276 
    L = ['%s=%r' % (key, value)
11277 
      for key, value in self.__dict__.iteritems()]
11278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11279 
 
11280 
  def __eq__(self, other):
11281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11282 
 
11283 
  def __ne__(self, other):
11284 
    return not (self == other)
11285 
 
3064 chandransh 11286 
class acceptOrder_result:
1113 chandransh 11287 
  """
11288 
  Attributes:
11289 
   - success
11290 
   - ex
11291 
  """
11292 
 
11293 
  thrift_spec = (
3064 chandransh 11294 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 11295 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11296 
  )
11297 
 
11298 
  def __init__(self, success=None, ex=None,):
11299 
    self.success = success
11300 
    self.ex = ex
11301 
 
11302 
  def read(self, iprot):
11303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11305 
      return
11306 
    iprot.readStructBegin()
11307 
    while True:
11308 
      (fname, ftype, fid) = iprot.readFieldBegin()
11309 
      if ftype == TType.STOP:
11310 
        break
11311 
      if fid == 0:
3064 chandransh 11312 
        if ftype == TType.BOOL:
11313 
          self.success = iprot.readBool();
1113 chandransh 11314 
        else:
11315 
          iprot.skip(ftype)
11316 
      elif fid == 1:
11317 
        if ftype == TType.STRUCT:
11318 
          self.ex = TransactionServiceException()
11319 
          self.ex.read(iprot)
11320 
        else:
11321 
          iprot.skip(ftype)
11322 
      else:
11323 
        iprot.skip(ftype)
11324 
      iprot.readFieldEnd()
11325 
    iprot.readStructEnd()
11326 
 
11327 
  def write(self, oprot):
11328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11330 
      return
3064 chandransh 11331 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 11332 
    if self.success is not None:
3064 chandransh 11333 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11334 
      oprot.writeBool(self.success)
1113 chandransh 11335 
      oprot.writeFieldEnd()
3431 rajveer 11336 
    if self.ex is not None:
1113 chandransh 11337 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11338 
      self.ex.write(oprot)
11339 
      oprot.writeFieldEnd()
11340 
    oprot.writeFieldStop()
11341 
    oprot.writeStructEnd()
11342 
 
3431 rajveer 11343 
  def validate(self):
11344 
    return
11345 
 
11346 
 
1113 chandransh 11347 
  def __repr__(self):
11348 
    L = ['%s=%r' % (key, value)
11349 
      for key, value in self.__dict__.iteritems()]
11350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11351 
 
11352 
  def __eq__(self, other):
11353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11354 
 
11355 
  def __ne__(self, other):
11356 
    return not (self == other)
11357 
 
3064 chandransh 11358 
class addBillingDetails_args:
1135 chandransh 11359 
  """
11360 
  Attributes:
3064 chandransh 11361 
   - orderId
11362 
   - invoice_number
4658 mandeep.dh 11363 
   - serialNumber
4283 anupam.sin 11364 
   - itemNumber
3064 chandransh 11365 
   - billed_by
4264 rajveer 11366 
   - jacketNumber
4283 anupam.sin 11367 
   - billingType
5110 mandeep.dh 11368 
   - fulfilmentWarehouseId
4763 rajveer 11369 
   - authorize
1135 chandransh 11370 
  """
11371 
 
11372 
  thrift_spec = (
11373 
    None, # 0
3064 chandransh 11374 
    (1, TType.I64, 'orderId', None, None, ), # 1
11375 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
4658 mandeep.dh 11376 
    (3, TType.STRING, 'serialNumber', None, None, ), # 3
4283 anupam.sin 11377 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
11378 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
11379 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
11380 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 11381 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 11382 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 11383 
  )
11384 
 
5110 mandeep.dh 11385 
  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 11386 
    self.orderId = orderId
11387 
    self.invoice_number = invoice_number
4658 mandeep.dh 11388 
    self.serialNumber = serialNumber
4283 anupam.sin 11389 
    self.itemNumber = itemNumber
3064 chandransh 11390 
    self.billed_by = billed_by
4264 rajveer 11391 
    self.jacketNumber = jacketNumber
4283 anupam.sin 11392 
    self.billingType = billingType
5110 mandeep.dh 11393 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 11394 
    self.authorize = authorize
1135 chandransh 11395 
 
11396 
  def read(self, iprot):
11397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11399 
      return
11400 
    iprot.readStructBegin()
11401 
    while True:
11402 
      (fname, ftype, fid) = iprot.readFieldBegin()
11403 
      if ftype == TType.STOP:
11404 
        break
11405 
      if fid == 1:
11406 
        if ftype == TType.I64:
3064 chandransh 11407 
          self.orderId = iprot.readI64();
1135 chandransh 11408 
        else:
11409 
          iprot.skip(ftype)
11410 
      elif fid == 2:
3064 chandransh 11411 
        if ftype == TType.STRING:
11412 
          self.invoice_number = iprot.readString();
1135 chandransh 11413 
        else:
11414 
          iprot.skip(ftype)
3064 chandransh 11415 
      elif fid == 3:
4658 mandeep.dh 11416 
        if ftype == TType.STRING:
11417 
          self.serialNumber = iprot.readString();
3064 chandransh 11418 
        else:
11419 
          iprot.skip(ftype)
11420 
      elif fid == 4:
11421 
        if ftype == TType.STRING:
11422 
          self.itemNumber = iprot.readString();
11423 
        else:
11424 
          iprot.skip(ftype)
11425 
      elif fid == 5:
11426 
        if ftype == TType.STRING:
4283 anupam.sin 11427 
          self.billed_by = iprot.readString();
3064 chandransh 11428 
        else:
11429 
          iprot.skip(ftype)
11430 
      elif fid == 6:
11431 
        if ftype == TType.I64:
4283 anupam.sin 11432 
          self.jacketNumber = iprot.readI64();
11433 
        else:
11434 
          iprot.skip(ftype)
11435 
      elif fid == 7:
11436 
        if ftype == TType.I64:
3064 chandransh 11437 
          self.billingType = iprot.readI64();
11438 
        else:
11439 
          iprot.skip(ftype)
4283 anupam.sin 11440 
      elif fid == 8:
11441 
        if ftype == TType.I64:
5110 mandeep.dh 11442 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 11443 
        else:
11444 
          iprot.skip(ftype)
4763 rajveer 11445 
      elif fid == 9:
11446 
        if ftype == TType.BOOL:
11447 
          self.authorize = iprot.readBool();
11448 
        else:
11449 
          iprot.skip(ftype)
1246 chandransh 11450 
      else:
11451 
        iprot.skip(ftype)
11452 
      iprot.readFieldEnd()
11453 
    iprot.readStructEnd()
11454 
 
11455 
  def write(self, oprot):
11456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11458 
      return
4283 anupam.sin 11459 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 11460 
    if self.orderId is not None:
3064 chandransh 11461 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11462 
      oprot.writeI64(self.orderId)
1246 chandransh 11463 
      oprot.writeFieldEnd()
4283 anupam.sin 11464 
    if self.invoice_number is not None:
11465 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
11466 
      oprot.writeString(self.invoice_number)
1246 chandransh 11467 
      oprot.writeFieldEnd()
4658 mandeep.dh 11468 
    if self.serialNumber is not None:
11469 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 3)
11470 
      oprot.writeString(self.serialNumber)
3064 chandransh 11471 
      oprot.writeFieldEnd()
3431 rajveer 11472 
    if self.itemNumber is not None:
3064 chandransh 11473 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
11474 
      oprot.writeString(self.itemNumber)
11475 
      oprot.writeFieldEnd()
4283 anupam.sin 11476 
    if self.billed_by is not None:
11477 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
11478 
      oprot.writeString(self.billed_by)
3064 chandransh 11479 
      oprot.writeFieldEnd()
4283 anupam.sin 11480 
    if self.jacketNumber is not None:
11481 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
11482 
      oprot.writeI64(self.jacketNumber)
11483 
      oprot.writeFieldEnd()
3431 rajveer 11484 
    if self.billingType is not None:
4283 anupam.sin 11485 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 11486 
      oprot.writeI64(self.billingType)
11487 
      oprot.writeFieldEnd()
5110 mandeep.dh 11488 
    if self.fulfilmentWarehouseId is not None:
11489 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
11490 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 11491 
      oprot.writeFieldEnd()
4763 rajveer 11492 
    if self.authorize is not None:
11493 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
11494 
      oprot.writeBool(self.authorize)
11495 
      oprot.writeFieldEnd()
1246 chandransh 11496 
    oprot.writeFieldStop()
11497 
    oprot.writeStructEnd()
11498 
 
3431 rajveer 11499 
  def validate(self):
11500 
    return
11501 
 
11502 
 
1246 chandransh 11503 
  def __repr__(self):
11504 
    L = ['%s=%r' % (key, value)
11505 
      for key, value in self.__dict__.iteritems()]
11506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11507 
 
11508 
  def __eq__(self, other):
11509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11510 
 
11511 
  def __ne__(self, other):
11512 
    return not (self == other)
11513 
 
4283 anupam.sin 11514 
class addBillingDetails_result:
1246 chandransh 11515 
  """
11516 
  Attributes:
3064 chandransh 11517 
   - success
1246 chandransh 11518 
   - ex
11519 
  """
11520 
 
11521 
  thrift_spec = (
3064 chandransh 11522 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 11523 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11524 
  )
11525 
 
3064 chandransh 11526 
  def __init__(self, success=None, ex=None,):
11527 
    self.success = success
1246 chandransh 11528 
    self.ex = ex
11529 
 
11530 
  def read(self, iprot):
11531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11533 
      return
11534 
    iprot.readStructBegin()
11535 
    while True:
11536 
      (fname, ftype, fid) = iprot.readFieldBegin()
11537 
      if ftype == TType.STOP:
11538 
        break
3064 chandransh 11539 
      if fid == 0:
11540 
        if ftype == TType.BOOL:
11541 
          self.success = iprot.readBool();
11542 
        else:
11543 
          iprot.skip(ftype)
11544 
      elif fid == 1:
1246 chandransh 11545 
        if ftype == TType.STRUCT:
11546 
          self.ex = TransactionServiceException()
11547 
          self.ex.read(iprot)
11548 
        else:
11549 
          iprot.skip(ftype)
11550 
      else:
11551 
        iprot.skip(ftype)
11552 
      iprot.readFieldEnd()
11553 
    iprot.readStructEnd()
11554 
 
11555 
  def write(self, oprot):
11556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11558 
      return
4283 anupam.sin 11559 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 11560 
    if self.success is not None:
3064 chandransh 11561 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11562 
      oprot.writeBool(self.success)
11563 
      oprot.writeFieldEnd()
3431 rajveer 11564 
    if self.ex is not None:
1246 chandransh 11565 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11566 
      self.ex.write(oprot)
11567 
      oprot.writeFieldEnd()
11568 
    oprot.writeFieldStop()
11569 
    oprot.writeStructEnd()
11570 
 
3431 rajveer 11571 
  def validate(self):
11572 
    return
11573 
 
11574 
 
1246 chandransh 11575 
  def __repr__(self):
11576 
    L = ['%s=%r' % (key, value)
11577 
      for key, value in self.__dict__.iteritems()]
11578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11579 
 
11580 
  def __eq__(self, other):
11581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11582 
 
11583 
  def __ne__(self, other):
11584 
    return not (self == other)
11585 
 
4579 rajveer 11586 
class addInvoiceNumber_args:
11587 
  """
11588 
  Attributes:
11589 
   - orderId
11590 
   - invoiceNumber
4763 rajveer 11591 
   - color
4579 rajveer 11592 
  """
11593 
 
11594 
  thrift_spec = (
11595 
    None, # 0
11596 
    (1, TType.I64, 'orderId', None, None, ), # 1
11597 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 11598 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 11599 
  )
11600 
 
4763 rajveer 11601 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 11602 
    self.orderId = orderId
11603 
    self.invoiceNumber = invoiceNumber
4763 rajveer 11604 
    self.color = color
4579 rajveer 11605 
 
11606 
  def read(self, iprot):
11607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11609 
      return
11610 
    iprot.readStructBegin()
11611 
    while True:
11612 
      (fname, ftype, fid) = iprot.readFieldBegin()
11613 
      if ftype == TType.STOP:
11614 
        break
11615 
      if fid == 1:
11616 
        if ftype == TType.I64:
11617 
          self.orderId = iprot.readI64();
11618 
        else:
11619 
          iprot.skip(ftype)
11620 
      elif fid == 2:
11621 
        if ftype == TType.STRING:
11622 
          self.invoiceNumber = iprot.readString();
11623 
        else:
11624 
          iprot.skip(ftype)
4763 rajveer 11625 
      elif fid == 3:
11626 
        if ftype == TType.STRING:
11627 
          self.color = iprot.readString();
11628 
        else:
11629 
          iprot.skip(ftype)
4579 rajveer 11630 
      else:
11631 
        iprot.skip(ftype)
11632 
      iprot.readFieldEnd()
11633 
    iprot.readStructEnd()
11634 
 
11635 
  def write(self, oprot):
11636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11638 
      return
11639 
    oprot.writeStructBegin('addInvoiceNumber_args')
11640 
    if self.orderId is not None:
11641 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11642 
      oprot.writeI64(self.orderId)
11643 
      oprot.writeFieldEnd()
11644 
    if self.invoiceNumber is not None:
11645 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
11646 
      oprot.writeString(self.invoiceNumber)
11647 
      oprot.writeFieldEnd()
4763 rajveer 11648 
    if self.color is not None:
11649 
      oprot.writeFieldBegin('color', TType.STRING, 3)
11650 
      oprot.writeString(self.color)
11651 
      oprot.writeFieldEnd()
4579 rajveer 11652 
    oprot.writeFieldStop()
11653 
    oprot.writeStructEnd()
11654 
 
11655 
  def validate(self):
11656 
    return
11657 
 
11658 
 
11659 
  def __repr__(self):
11660 
    L = ['%s=%r' % (key, value)
11661 
      for key, value in self.__dict__.iteritems()]
11662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11663 
 
11664 
  def __eq__(self, other):
11665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11666 
 
11667 
  def __ne__(self, other):
11668 
    return not (self == other)
11669 
 
11670 
class addInvoiceNumber_result:
11671 
  """
11672 
  Attributes:
11673 
   - ex
11674 
  """
11675 
 
11676 
  thrift_spec = (
11677 
    None, # 0
11678 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11679 
  )
11680 
 
11681 
  def __init__(self, ex=None,):
11682 
    self.ex = ex
11683 
 
11684 
  def read(self, iprot):
11685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11687 
      return
11688 
    iprot.readStructBegin()
11689 
    while True:
11690 
      (fname, ftype, fid) = iprot.readFieldBegin()
11691 
      if ftype == TType.STOP:
11692 
        break
11693 
      if fid == 1:
11694 
        if ftype == TType.STRUCT:
11695 
          self.ex = TransactionServiceException()
11696 
          self.ex.read(iprot)
11697 
        else:
11698 
          iprot.skip(ftype)
11699 
      else:
11700 
        iprot.skip(ftype)
11701 
      iprot.readFieldEnd()
11702 
    iprot.readStructEnd()
11703 
 
11704 
  def write(self, oprot):
11705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11707 
      return
11708 
    oprot.writeStructBegin('addInvoiceNumber_result')
11709 
    if self.ex is not None:
11710 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11711 
      self.ex.write(oprot)
11712 
      oprot.writeFieldEnd()
11713 
    oprot.writeFieldStop()
11714 
    oprot.writeStructEnd()
11715 
 
11716 
  def validate(self):
11717 
    return
11718 
 
11719 
 
11720 
  def __repr__(self):
11721 
    L = ['%s=%r' % (key, value)
11722 
      for key, value in self.__dict__.iteritems()]
11723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11724 
 
11725 
  def __eq__(self, other):
11726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11727 
 
11728 
  def __ne__(self, other):
11729 
    return not (self == other)
11730 
 
4910 phani.kuma 11731 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 11732 
  """
11733 
  Attributes:
3064 chandransh 11734 
   - warehouseId
1408 ankur.sing 11735 
   - providerId
3064 chandransh 11736 
   - cod
4910 phani.kuma 11737 
   - orderIds
1408 ankur.sing 11738 
  """
11739 
 
11740 
  thrift_spec = (
11741 
    None, # 0
3064 chandransh 11742 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11743 
    (2, TType.I64, 'providerId', None, None, ), # 2
11744 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 11745 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 11746 
  )
11747 
 
4910 phani.kuma 11748 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 11749 
    self.warehouseId = warehouseId
1408 ankur.sing 11750 
    self.providerId = providerId
3064 chandransh 11751 
    self.cod = cod
4910 phani.kuma 11752 
    self.orderIds = orderIds
1408 ankur.sing 11753 
 
11754 
  def read(self, iprot):
11755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11757 
      return
11758 
    iprot.readStructBegin()
11759 
    while True:
11760 
      (fname, ftype, fid) = iprot.readFieldBegin()
11761 
      if ftype == TType.STOP:
11762 
        break
11763 
      if fid == 1:
11764 
        if ftype == TType.I64:
3064 chandransh 11765 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 11766 
        else:
11767 
          iprot.skip(ftype)
11768 
      elif fid == 2:
11769 
        if ftype == TType.I64:
3064 chandransh 11770 
          self.providerId = iprot.readI64();
1408 ankur.sing 11771 
        else:
11772 
          iprot.skip(ftype)
3064 chandransh 11773 
      elif fid == 3:
11774 
        if ftype == TType.BOOL:
11775 
          self.cod = iprot.readBool();
11776 
        else:
11777 
          iprot.skip(ftype)
4910 phani.kuma 11778 
      elif fid == 4:
11779 
        if ftype == TType.LIST:
11780 
          self.orderIds = []
5031 varun.gupt 11781 
          (_etype213, _size210) = iprot.readListBegin()
11782 
          for _i214 in xrange(_size210):
11783 
            _elem215 = iprot.readI64();
11784 
            self.orderIds.append(_elem215)
4910 phani.kuma 11785 
          iprot.readListEnd()
11786 
        else:
11787 
          iprot.skip(ftype)
1408 ankur.sing 11788 
      else:
11789 
        iprot.skip(ftype)
11790 
      iprot.readFieldEnd()
11791 
    iprot.readStructEnd()
11792 
 
11793 
  def write(self, oprot):
11794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11796 
      return
4910 phani.kuma 11797 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 11798 
    if self.warehouseId is not None:
3064 chandransh 11799 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11800 
      oprot.writeI64(self.warehouseId)
11801 
      oprot.writeFieldEnd()
3431 rajveer 11802 
    if self.providerId is not None:
3064 chandransh 11803 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 11804 
      oprot.writeI64(self.providerId)
11805 
      oprot.writeFieldEnd()
3431 rajveer 11806 
    if self.cod is not None:
3064 chandransh 11807 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
11808 
      oprot.writeBool(self.cod)
1408 ankur.sing 11809 
      oprot.writeFieldEnd()
4910 phani.kuma 11810 
    if self.orderIds is not None:
11811 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
11812 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5031 varun.gupt 11813 
      for iter216 in self.orderIds:
11814 
        oprot.writeI64(iter216)
4910 phani.kuma 11815 
      oprot.writeListEnd()
11816 
      oprot.writeFieldEnd()
1408 ankur.sing 11817 
    oprot.writeFieldStop()
11818 
    oprot.writeStructEnd()
11819 
 
3431 rajveer 11820 
  def validate(self):
11821 
    return
11822 
 
11823 
 
1408 ankur.sing 11824 
  def __repr__(self):
11825 
    L = ['%s=%r' % (key, value)
11826 
      for key, value in self.__dict__.iteritems()]
11827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11828 
 
11829 
  def __eq__(self, other):
11830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11831 
 
11832 
  def __ne__(self, other):
11833 
    return not (self == other)
11834 
 
4910 phani.kuma 11835 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 11836 
  """
11837 
  Attributes:
11838 
   - success
3064 chandransh 11839 
   - ex
1408 ankur.sing 11840 
  """
11841 
 
11842 
  thrift_spec = (
3064 chandransh 11843 
    (0, TType.BOOL, 'success', None, None, ), # 0
11844 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 11845 
  )
11846 
 
3064 chandransh 11847 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 11848 
    self.success = success
3064 chandransh 11849 
    self.ex = ex
1408 ankur.sing 11850 
 
11851 
  def read(self, iprot):
11852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11854 
      return
11855 
    iprot.readStructBegin()
11856 
    while True:
11857 
      (fname, ftype, fid) = iprot.readFieldBegin()
11858 
      if ftype == TType.STOP:
11859 
        break
11860 
      if fid == 0:
3064 chandransh 11861 
        if ftype == TType.BOOL:
11862 
          self.success = iprot.readBool();
1408 ankur.sing 11863 
        else:
11864 
          iprot.skip(ftype)
3064 chandransh 11865 
      elif fid == 1:
11866 
        if ftype == TType.STRUCT:
11867 
          self.ex = TransactionServiceException()
11868 
          self.ex.read(iprot)
11869 
        else:
11870 
          iprot.skip(ftype)
1408 ankur.sing 11871 
      else:
11872 
        iprot.skip(ftype)
11873 
      iprot.readFieldEnd()
11874 
    iprot.readStructEnd()
11875 
 
11876 
  def write(self, oprot):
11877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11879 
      return
4910 phani.kuma 11880 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 11881 
    if self.success is not None:
3064 chandransh 11882 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11883 
      oprot.writeBool(self.success)
1408 ankur.sing 11884 
      oprot.writeFieldEnd()
3431 rajveer 11885 
    if self.ex is not None:
3064 chandransh 11886 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11887 
      self.ex.write(oprot)
11888 
      oprot.writeFieldEnd()
1408 ankur.sing 11889 
    oprot.writeFieldStop()
11890 
    oprot.writeStructEnd()
11891 
 
3431 rajveer 11892 
  def validate(self):
11893 
    return
11894 
 
11895 
 
1408 ankur.sing 11896 
  def __repr__(self):
11897 
    L = ['%s=%r' % (key, value)
11898 
      for key, value in self.__dict__.iteritems()]
11899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11900 
 
11901 
  def __eq__(self, other):
11902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11903 
 
11904 
  def __ne__(self, other):
11905 
    return not (self == other)
11906 
 
4910 phani.kuma 11907 
class markOrdersAsPickedUp_args:
4410 rajveer 11908 
  """
11909 
  Attributes:
11910 
   - providerId
4910 phani.kuma 11911 
   - pickupDetails
4410 rajveer 11912 
  """
11913 
 
11914 
  thrift_spec = (
11915 
    None, # 0
4910 phani.kuma 11916 
    (1, TType.I64, 'providerId', None, None, ), # 1
11917 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 11918 
  )
11919 
 
4910 phani.kuma 11920 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 11921 
    self.providerId = providerId
4910 phani.kuma 11922 
    self.pickupDetails = pickupDetails
4410 rajveer 11923 
 
11924 
  def read(self, iprot):
11925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11927 
      return
11928 
    iprot.readStructBegin()
11929 
    while True:
11930 
      (fname, ftype, fid) = iprot.readFieldBegin()
11931 
      if ftype == TType.STOP:
11932 
        break
11933 
      if fid == 1:
11934 
        if ftype == TType.I64:
4910 phani.kuma 11935 
          self.providerId = iprot.readI64();
4410 rajveer 11936 
        else:
11937 
          iprot.skip(ftype)
11938 
      elif fid == 2:
4910 phani.kuma 11939 
        if ftype == TType.MAP:
11940 
          self.pickupDetails = {}
5031 varun.gupt 11941 
          (_ktype218, _vtype219, _size217 ) = iprot.readMapBegin()
11942 
          for _i221 in xrange(_size217):
11943 
            _key222 = iprot.readString();
11944 
            _val223 = iprot.readString();
11945 
            self.pickupDetails[_key222] = _val223
4910 phani.kuma 11946 
          iprot.readMapEnd()
4410 rajveer 11947 
        else:
11948 
          iprot.skip(ftype)
11949 
      else:
11950 
        iprot.skip(ftype)
11951 
      iprot.readFieldEnd()
11952 
    iprot.readStructEnd()
11953 
 
11954 
  def write(self, oprot):
11955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11957 
      return
4910 phani.kuma 11958 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 11959 
    if self.providerId is not None:
4910 phani.kuma 11960 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 11961 
      oprot.writeI64(self.providerId)
11962 
      oprot.writeFieldEnd()
4910 phani.kuma 11963 
    if self.pickupDetails is not None:
11964 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
11965 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 11966 
      for kiter224,viter225 in self.pickupDetails.items():
11967 
        oprot.writeString(kiter224)
11968 
        oprot.writeString(viter225)
4910 phani.kuma 11969 
      oprot.writeMapEnd()
4410 rajveer 11970 
      oprot.writeFieldEnd()
11971 
    oprot.writeFieldStop()
11972 
    oprot.writeStructEnd()
11973 
 
11974 
  def validate(self):
11975 
    return
11976 
 
11977 
 
11978 
  def __repr__(self):
11979 
    L = ['%s=%r' % (key, value)
11980 
      for key, value in self.__dict__.iteritems()]
11981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11982 
 
11983 
  def __eq__(self, other):
11984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11985 
 
11986 
  def __ne__(self, other):
11987 
    return not (self == other)
11988 
 
4910 phani.kuma 11989 
class markOrdersAsPickedUp_result:
4410 rajveer 11990 
  """
11991 
  Attributes:
11992 
   - ex
11993 
  """
11994 
 
11995 
  thrift_spec = (
4910 phani.kuma 11996 
    None, # 0
4410 rajveer 11997 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11998 
  )
11999 
 
4910 phani.kuma 12000 
  def __init__(self, ex=None,):
4410 rajveer 12001 
    self.ex = ex
12002 
 
12003 
  def read(self, iprot):
12004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12006 
      return
12007 
    iprot.readStructBegin()
12008 
    while True:
12009 
      (fname, ftype, fid) = iprot.readFieldBegin()
12010 
      if ftype == TType.STOP:
12011 
        break
4910 phani.kuma 12012 
      if fid == 1:
4410 rajveer 12013 
        if ftype == TType.STRUCT:
12014 
          self.ex = TransactionServiceException()
12015 
          self.ex.read(iprot)
12016 
        else:
12017 
          iprot.skip(ftype)
12018 
      else:
12019 
        iprot.skip(ftype)
12020 
      iprot.readFieldEnd()
12021 
    iprot.readStructEnd()
12022 
 
12023 
  def write(self, oprot):
12024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12026 
      return
4910 phani.kuma 12027 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 12028 
    if self.ex is not None:
12029 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12030 
      self.ex.write(oprot)
12031 
      oprot.writeFieldEnd()
12032 
    oprot.writeFieldStop()
12033 
    oprot.writeStructEnd()
12034 
 
12035 
  def validate(self):
12036 
    return
12037 
 
12038 
 
12039 
  def __repr__(self):
12040 
    L = ['%s=%r' % (key, value)
12041 
      for key, value in self.__dict__.iteritems()]
12042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12043 
 
12044 
  def __eq__(self, other):
12045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12046 
 
12047 
  def __ne__(self, other):
12048 
    return not (self == other)
12049 
 
4910 phani.kuma 12050 
class getOrdersNotPickedUp_args:
304 ashish 12051 
  """
12052 
  Attributes:
3064 chandransh 12053 
   - providerId
304 ashish 12054 
  """
94 ashish 12055 
 
304 ashish 12056 
  thrift_spec = (
12057 
    None, # 0
3064 chandransh 12058 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 12059 
  )
12060 
 
4910 phani.kuma 12061 
  def __init__(self, providerId=None,):
3064 chandransh 12062 
    self.providerId = providerId
304 ashish 12063 
 
12064 
  def read(self, iprot):
12065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12067 
      return
12068 
    iprot.readStructBegin()
12069 
    while True:
12070 
      (fname, ftype, fid) = iprot.readFieldBegin()
12071 
      if ftype == TType.STOP:
12072 
        break
12073 
      if fid == 1:
12074 
        if ftype == TType.I64:
3064 chandransh 12075 
          self.providerId = iprot.readI64();
304 ashish 12076 
        else:
12077 
          iprot.skip(ftype)
12078 
      else:
12079 
        iprot.skip(ftype)
12080 
      iprot.readFieldEnd()
12081 
    iprot.readStructEnd()
12082 
 
12083 
  def write(self, oprot):
12084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12086 
      return
4910 phani.kuma 12087 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 12088 
    if self.providerId is not None:
3064 chandransh 12089 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12090 
      oprot.writeI64(self.providerId)
304 ashish 12091 
      oprot.writeFieldEnd()
12092 
    oprot.writeFieldStop()
12093 
    oprot.writeStructEnd()
12094 
 
3431 rajveer 12095 
  def validate(self):
12096 
    return
12097 
 
12098 
 
304 ashish 12099 
  def __repr__(self):
12100 
    L = ['%s=%r' % (key, value)
12101 
      for key, value in self.__dict__.iteritems()]
12102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12103 
 
12104 
  def __eq__(self, other):
12105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12106 
 
12107 
  def __ne__(self, other):
12108 
    return not (self == other)
12109 
 
4910 phani.kuma 12110 
class getOrdersNotPickedUp_result:
304 ashish 12111 
  """
12112 
  Attributes:
12113 
   - success
12114 
  """
12115 
 
12116 
  thrift_spec = (
3064 chandransh 12117 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 12118 
  )
12119 
 
4910 phani.kuma 12120 
  def __init__(self, success=None,):
304 ashish 12121 
    self.success = success
12122 
 
12123 
  def read(self, iprot):
12124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12126 
      return
12127 
    iprot.readStructBegin()
12128 
    while True:
12129 
      (fname, ftype, fid) = iprot.readFieldBegin()
12130 
      if ftype == TType.STOP:
12131 
        break
12132 
      if fid == 0:
12133 
        if ftype == TType.LIST:
12134 
          self.success = []
5031 varun.gupt 12135 
          (_etype229, _size226) = iprot.readListBegin()
12136 
          for _i230 in xrange(_size226):
12137 
            _elem231 = Order()
12138 
            _elem231.read(iprot)
12139 
            self.success.append(_elem231)
304 ashish 12140 
          iprot.readListEnd()
12141 
        else:
12142 
          iprot.skip(ftype)
12143 
      else:
12144 
        iprot.skip(ftype)
12145 
      iprot.readFieldEnd()
12146 
    iprot.readStructEnd()
12147 
 
12148 
  def write(self, oprot):
12149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12151 
      return
4910 phani.kuma 12152 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 12153 
    if self.success is not None:
304 ashish 12154 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12155 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12156 
      for iter232 in self.success:
12157 
        iter232.write(oprot)
304 ashish 12158 
      oprot.writeListEnd()
12159 
      oprot.writeFieldEnd()
12160 
    oprot.writeFieldStop()
12161 
    oprot.writeStructEnd()
12162 
 
3431 rajveer 12163 
  def validate(self):
12164 
    return
12165 
 
12166 
 
304 ashish 12167 
  def __repr__(self):
12168 
    L = ['%s=%r' % (key, value)
12169 
      for key, value in self.__dict__.iteritems()]
12170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12171 
 
12172 
  def __eq__(self, other):
12173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12174 
 
12175 
  def __ne__(self, other):
12176 
    return not (self == other)
12177 
 
3064 chandransh 12178 
class markOrdersAsDelivered_args:
304 ashish 12179 
  """
12180 
  Attributes:
3064 chandransh 12181 
   - providerId
12182 
   - deliveredOrders
304 ashish 12183 
  """
12184 
 
12185 
  thrift_spec = (
12186 
    None, # 0
3064 chandransh 12187 
    (1, TType.I64, 'providerId', None, None, ), # 1
12188 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 12189 
  )
12190 
 
3064 chandransh 12191 
  def __init__(self, providerId=None, deliveredOrders=None,):
12192 
    self.providerId = providerId
12193 
    self.deliveredOrders = deliveredOrders
304 ashish 12194 
 
12195 
  def read(self, iprot):
12196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12198 
      return
12199 
    iprot.readStructBegin()
12200 
    while True:
12201 
      (fname, ftype, fid) = iprot.readFieldBegin()
12202 
      if ftype == TType.STOP:
12203 
        break
12204 
      if fid == 1:
12205 
        if ftype == TType.I64:
3064 chandransh 12206 
          self.providerId = iprot.readI64();
304 ashish 12207 
        else:
12208 
          iprot.skip(ftype)
12209 
      elif fid == 2:
3064 chandransh 12210 
        if ftype == TType.MAP:
12211 
          self.deliveredOrders = {}
5031 varun.gupt 12212 
          (_ktype234, _vtype235, _size233 ) = iprot.readMapBegin()
12213 
          for _i237 in xrange(_size233):
12214 
            _key238 = iprot.readString();
12215 
            _val239 = iprot.readString();
12216 
            self.deliveredOrders[_key238] = _val239
3064 chandransh 12217 
          iprot.readMapEnd()
304 ashish 12218 
        else:
12219 
          iprot.skip(ftype)
12220 
      else:
12221 
        iprot.skip(ftype)
12222 
      iprot.readFieldEnd()
12223 
    iprot.readStructEnd()
12224 
 
12225 
  def write(self, oprot):
12226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12228 
      return
3064 chandransh 12229 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 12230 
    if self.providerId is not None:
3064 chandransh 12231 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12232 
      oprot.writeI64(self.providerId)
304 ashish 12233 
      oprot.writeFieldEnd()
3431 rajveer 12234 
    if self.deliveredOrders is not None:
3064 chandransh 12235 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
12236 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
5031 varun.gupt 12237 
      for kiter240,viter241 in self.deliveredOrders.items():
12238 
        oprot.writeString(kiter240)
12239 
        oprot.writeString(viter241)
3064 chandransh 12240 
      oprot.writeMapEnd()
304 ashish 12241 
      oprot.writeFieldEnd()
12242 
    oprot.writeFieldStop()
12243 
    oprot.writeStructEnd()
12244 
 
3431 rajveer 12245 
  def validate(self):
12246 
    return
12247 
 
12248 
 
304 ashish 12249 
  def __repr__(self):
12250 
    L = ['%s=%r' % (key, value)
12251 
      for key, value in self.__dict__.iteritems()]
12252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12253 
 
12254 
  def __eq__(self, other):
12255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12256 
 
12257 
  def __ne__(self, other):
12258 
    return not (self == other)
12259 
 
3064 chandransh 12260 
class markOrdersAsDelivered_result:
12261 
  """
12262 
  Attributes:
12263 
   - ex
12264 
  """
304 ashish 12265 
 
12266 
  thrift_spec = (
3064 chandransh 12267 
    None, # 0
12268 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 12269 
  )
12270 
 
3064 chandransh 12271 
  def __init__(self, ex=None,):
12272 
    self.ex = ex
304 ashish 12273 
 
1596 ankur.sing 12274 
  def read(self, iprot):
12275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12277 
      return
12278 
    iprot.readStructBegin()
12279 
    while True:
12280 
      (fname, ftype, fid) = iprot.readFieldBegin()
12281 
      if ftype == TType.STOP:
12282 
        break
3064 chandransh 12283 
      if fid == 1:
12284 
        if ftype == TType.STRUCT:
12285 
          self.ex = TransactionServiceException()
12286 
          self.ex.read(iprot)
12287 
        else:
12288 
          iprot.skip(ftype)
1596 ankur.sing 12289 
      else:
12290 
        iprot.skip(ftype)
12291 
      iprot.readFieldEnd()
12292 
    iprot.readStructEnd()
12293 
 
12294 
  def write(self, oprot):
12295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12297 
      return
3064 chandransh 12298 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 12299 
    if self.ex is not None:
3064 chandransh 12300 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12301 
      self.ex.write(oprot)
12302 
      oprot.writeFieldEnd()
1596 ankur.sing 12303 
    oprot.writeFieldStop()
12304 
    oprot.writeStructEnd()
12305 
 
3431 rajveer 12306 
  def validate(self):
12307 
    return
12308 
 
12309 
 
1596 ankur.sing 12310 
  def __repr__(self):
12311 
    L = ['%s=%r' % (key, value)
12312 
      for key, value in self.__dict__.iteritems()]
12313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12314 
 
12315 
  def __eq__(self, other):
12316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12317 
 
12318 
  def __ne__(self, other):
12319 
    return not (self == other)
12320 
 
4910 phani.kuma 12321 
class markAsRTOrders_args:
1596 ankur.sing 12322 
  """
12323 
  Attributes:
3064 chandransh 12324 
   - providerId
12325 
   - returnedOrders
1596 ankur.sing 12326 
  """
12327 
 
12328 
  thrift_spec = (
3064 chandransh 12329 
    None, # 0
12330 
    (1, TType.I64, 'providerId', None, None, ), # 1
12331 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 12332 
  )
12333 
 
3064 chandransh 12334 
  def __init__(self, providerId=None, returnedOrders=None,):
12335 
    self.providerId = providerId
12336 
    self.returnedOrders = returnedOrders
1596 ankur.sing 12337 
 
12338 
  def read(self, iprot):
12339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12341 
      return
12342 
    iprot.readStructBegin()
12343 
    while True:
12344 
      (fname, ftype, fid) = iprot.readFieldBegin()
12345 
      if ftype == TType.STOP:
12346 
        break
3064 chandransh 12347 
      if fid == 1:
1596 ankur.sing 12348 
        if ftype == TType.I64:
3064 chandransh 12349 
          self.providerId = iprot.readI64();
1596 ankur.sing 12350 
        else:
12351 
          iprot.skip(ftype)
3064 chandransh 12352 
      elif fid == 2:
12353 
        if ftype == TType.MAP:
12354 
          self.returnedOrders = {}
5031 varun.gupt 12355 
          (_ktype243, _vtype244, _size242 ) = iprot.readMapBegin()
12356 
          for _i246 in xrange(_size242):
12357 
            _key247 = iprot.readString();
12358 
            _val248 = iprot.readString();
12359 
            self.returnedOrders[_key247] = _val248
3064 chandransh 12360 
          iprot.readMapEnd()
12361 
        else:
12362 
          iprot.skip(ftype)
1596 ankur.sing 12363 
      else:
12364 
        iprot.skip(ftype)
12365 
      iprot.readFieldEnd()
12366 
    iprot.readStructEnd()
12367 
 
12368 
  def write(self, oprot):
12369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12371 
      return
4910 phani.kuma 12372 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 12373 
    if self.providerId is not None:
3064 chandransh 12374 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12375 
      oprot.writeI64(self.providerId)
1596 ankur.sing 12376 
      oprot.writeFieldEnd()
3431 rajveer 12377 
    if self.returnedOrders is not None:
3064 chandransh 12378 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
12379 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
5031 varun.gupt 12380 
      for kiter249,viter250 in self.returnedOrders.items():
12381 
        oprot.writeString(kiter249)
12382 
        oprot.writeString(viter250)
3064 chandransh 12383 
      oprot.writeMapEnd()
12384 
      oprot.writeFieldEnd()
1596 ankur.sing 12385 
    oprot.writeFieldStop()
12386 
    oprot.writeStructEnd()
12387 
 
3431 rajveer 12388 
  def validate(self):
12389 
    return
12390 
 
12391 
 
1596 ankur.sing 12392 
  def __repr__(self):
12393 
    L = ['%s=%r' % (key, value)
12394 
      for key, value in self.__dict__.iteritems()]
12395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12396 
 
12397 
  def __eq__(self, other):
12398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12399 
 
12400 
  def __ne__(self, other):
12401 
    return not (self == other)
12402 
 
4910 phani.kuma 12403 
class markAsRTOrders_result:
3064 chandransh 12404 
  """
12405 
  Attributes:
12406 
   - ex
12407 
  """
1596 ankur.sing 12408 
 
1627 ankur.sing 12409 
  thrift_spec = (
3064 chandransh 12410 
    None, # 0
12411 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12412 
  )
12413 
 
3064 chandransh 12414 
  def __init__(self, ex=None,):
12415 
    self.ex = ex
12416 
 
1627 ankur.sing 12417 
  def read(self, iprot):
12418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12420 
      return
12421 
    iprot.readStructBegin()
12422 
    while True:
12423 
      (fname, ftype, fid) = iprot.readFieldBegin()
12424 
      if ftype == TType.STOP:
12425 
        break
3064 chandransh 12426 
      if fid == 1:
12427 
        if ftype == TType.STRUCT:
12428 
          self.ex = TransactionServiceException()
12429 
          self.ex.read(iprot)
12430 
        else:
12431 
          iprot.skip(ftype)
1627 ankur.sing 12432 
      else:
12433 
        iprot.skip(ftype)
12434 
      iprot.readFieldEnd()
12435 
    iprot.readStructEnd()
12436 
 
12437 
  def write(self, oprot):
12438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12440 
      return
4910 phani.kuma 12441 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 12442 
    if self.ex is not None:
3064 chandransh 12443 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12444 
      self.ex.write(oprot)
12445 
      oprot.writeFieldEnd()
1627 ankur.sing 12446 
    oprot.writeFieldStop()
12447 
    oprot.writeStructEnd()
12448 
 
3431 rajveer 12449 
  def validate(self):
12450 
    return
12451 
 
12452 
 
1627 ankur.sing 12453 
  def __repr__(self):
12454 
    L = ['%s=%r' % (key, value)
12455 
      for key, value in self.__dict__.iteritems()]
12456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12457 
 
12458 
  def __eq__(self, other):
12459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12460 
 
12461 
  def __ne__(self, other):
12462 
    return not (self == other)
12463 
 
4910 phani.kuma 12464 
class getRTOrders_args:
12465 
  """
12466 
  Attributes:
12467 
   - providerId
12468 
  """
12469 
 
12470 
  thrift_spec = (
12471 
    None, # 0
12472 
    (1, TType.I64, 'providerId', None, None, ), # 1
12473 
  )
12474 
 
12475 
  def __init__(self, providerId=None,):
12476 
    self.providerId = providerId
12477 
 
12478 
  def read(self, iprot):
12479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12481 
      return
12482 
    iprot.readStructBegin()
12483 
    while True:
12484 
      (fname, ftype, fid) = iprot.readFieldBegin()
12485 
      if ftype == TType.STOP:
12486 
        break
12487 
      if fid == 1:
12488 
        if ftype == TType.I64:
12489 
          self.providerId = iprot.readI64();
12490 
        else:
12491 
          iprot.skip(ftype)
12492 
      else:
12493 
        iprot.skip(ftype)
12494 
      iprot.readFieldEnd()
12495 
    iprot.readStructEnd()
12496 
 
12497 
  def write(self, oprot):
12498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12500 
      return
12501 
    oprot.writeStructBegin('getRTOrders_args')
12502 
    if self.providerId is not None:
12503 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12504 
      oprot.writeI64(self.providerId)
12505 
      oprot.writeFieldEnd()
12506 
    oprot.writeFieldStop()
12507 
    oprot.writeStructEnd()
12508 
 
12509 
  def validate(self):
12510 
    return
12511 
 
12512 
 
12513 
  def __repr__(self):
12514 
    L = ['%s=%r' % (key, value)
12515 
      for key, value in self.__dict__.iteritems()]
12516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12517 
 
12518 
  def __eq__(self, other):
12519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12520 
 
12521 
  def __ne__(self, other):
12522 
    return not (self == other)
12523 
 
12524 
class getRTOrders_result:
12525 
  """
12526 
  Attributes:
12527 
   - success
12528 
  """
12529 
 
12530 
  thrift_spec = (
12531 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12532 
  )
12533 
 
12534 
  def __init__(self, success=None,):
12535 
    self.success = success
12536 
 
12537 
  def read(self, iprot):
12538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12540 
      return
12541 
    iprot.readStructBegin()
12542 
    while True:
12543 
      (fname, ftype, fid) = iprot.readFieldBegin()
12544 
      if ftype == TType.STOP:
12545 
        break
12546 
      if fid == 0:
12547 
        if ftype == TType.LIST:
12548 
          self.success = []
5031 varun.gupt 12549 
          (_etype254, _size251) = iprot.readListBegin()
12550 
          for _i255 in xrange(_size251):
12551 
            _elem256 = Order()
12552 
            _elem256.read(iprot)
12553 
            self.success.append(_elem256)
4910 phani.kuma 12554 
          iprot.readListEnd()
12555 
        else:
12556 
          iprot.skip(ftype)
12557 
      else:
12558 
        iprot.skip(ftype)
12559 
      iprot.readFieldEnd()
12560 
    iprot.readStructEnd()
12561 
 
12562 
  def write(self, oprot):
12563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12565 
      return
12566 
    oprot.writeStructBegin('getRTOrders_result')
12567 
    if self.success is not None:
12568 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12569 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12570 
      for iter257 in self.success:
12571 
        iter257.write(oprot)
4910 phani.kuma 12572 
      oprot.writeListEnd()
12573 
      oprot.writeFieldEnd()
12574 
    oprot.writeFieldStop()
12575 
    oprot.writeStructEnd()
12576 
 
12577 
  def validate(self):
12578 
    return
12579 
 
12580 
 
12581 
  def __repr__(self):
12582 
    L = ['%s=%r' % (key, value)
12583 
      for key, value in self.__dict__.iteritems()]
12584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12585 
 
12586 
  def __eq__(self, other):
12587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12588 
 
12589 
  def __ne__(self, other):
12590 
    return not (self == other)
12591 
 
3064 chandransh 12592 
class updateNonDeliveryReason_args:
1627 ankur.sing 12593 
  """
12594 
  Attributes:
3064 chandransh 12595 
   - providerId
12596 
   - undeliveredOrders
1627 ankur.sing 12597 
  """
12598 
 
12599 
  thrift_spec = (
3064 chandransh 12600 
    None, # 0
12601 
    (1, TType.I64, 'providerId', None, None, ), # 1
12602 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 12603 
  )
12604 
 
3064 chandransh 12605 
  def __init__(self, providerId=None, undeliveredOrders=None,):
12606 
    self.providerId = providerId
12607 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 12608 
 
12609 
  def read(self, iprot):
12610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12612 
      return
12613 
    iprot.readStructBegin()
12614 
    while True:
12615 
      (fname, ftype, fid) = iprot.readFieldBegin()
12616 
      if ftype == TType.STOP:
12617 
        break
3064 chandransh 12618 
      if fid == 1:
1627 ankur.sing 12619 
        if ftype == TType.I64:
3064 chandransh 12620 
          self.providerId = iprot.readI64();
1627 ankur.sing 12621 
        else:
12622 
          iprot.skip(ftype)
3064 chandransh 12623 
      elif fid == 2:
12624 
        if ftype == TType.MAP:
12625 
          self.undeliveredOrders = {}
5031 varun.gupt 12626 
          (_ktype259, _vtype260, _size258 ) = iprot.readMapBegin()
12627 
          for _i262 in xrange(_size258):
12628 
            _key263 = iprot.readString();
12629 
            _val264 = iprot.readString();
12630 
            self.undeliveredOrders[_key263] = _val264
3064 chandransh 12631 
          iprot.readMapEnd()
12632 
        else:
12633 
          iprot.skip(ftype)
1627 ankur.sing 12634 
      else:
12635 
        iprot.skip(ftype)
12636 
      iprot.readFieldEnd()
12637 
    iprot.readStructEnd()
12638 
 
12639 
  def write(self, oprot):
12640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12642 
      return
3064 chandransh 12643 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 12644 
    if self.providerId is not None:
3064 chandransh 12645 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12646 
      oprot.writeI64(self.providerId)
1627 ankur.sing 12647 
      oprot.writeFieldEnd()
3431 rajveer 12648 
    if self.undeliveredOrders is not None:
3064 chandransh 12649 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
12650 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
5031 varun.gupt 12651 
      for kiter265,viter266 in self.undeliveredOrders.items():
12652 
        oprot.writeString(kiter265)
12653 
        oprot.writeString(viter266)
3064 chandransh 12654 
      oprot.writeMapEnd()
12655 
      oprot.writeFieldEnd()
1627 ankur.sing 12656 
    oprot.writeFieldStop()
12657 
    oprot.writeStructEnd()
12658 
 
3431 rajveer 12659 
  def validate(self):
12660 
    return
12661 
 
12662 
 
1627 ankur.sing 12663 
  def __repr__(self):
12664 
    L = ['%s=%r' % (key, value)
12665 
      for key, value in self.__dict__.iteritems()]
12666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12667 
 
12668 
  def __eq__(self, other):
12669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12670 
 
12671 
  def __ne__(self, other):
12672 
    return not (self == other)
12673 
 
3064 chandransh 12674 
class updateNonDeliveryReason_result:
1627 ankur.sing 12675 
  """
12676 
  Attributes:
3064 chandransh 12677 
   - ex
1627 ankur.sing 12678 
  """
12679 
 
12680 
  thrift_spec = (
4910 phani.kuma 12681 
    None, # 0
3064 chandransh 12682 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 12683 
  )
12684 
 
4910 phani.kuma 12685 
  def __init__(self, ex=None,):
3064 chandransh 12686 
    self.ex = ex
1627 ankur.sing 12687 
 
12688 
  def read(self, iprot):
12689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12691 
      return
12692 
    iprot.readStructBegin()
12693 
    while True:
12694 
      (fname, ftype, fid) = iprot.readFieldBegin()
12695 
      if ftype == TType.STOP:
12696 
        break
4910 phani.kuma 12697 
      if fid == 1:
12698 
        if ftype == TType.STRUCT:
12699 
          self.ex = TransactionServiceException()
12700 
          self.ex.read(iprot)
12701 
        else:
12702 
          iprot.skip(ftype)
12703 
      else:
12704 
        iprot.skip(ftype)
12705 
      iprot.readFieldEnd()
12706 
    iprot.readStructEnd()
12707 
 
12708 
  def write(self, oprot):
12709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12711 
      return
12712 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
12713 
    if self.ex is not None:
12714 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12715 
      self.ex.write(oprot)
12716 
      oprot.writeFieldEnd()
12717 
    oprot.writeFieldStop()
12718 
    oprot.writeStructEnd()
12719 
 
12720 
  def validate(self):
12721 
    return
12722 
 
12723 
 
12724 
  def __repr__(self):
12725 
    L = ['%s=%r' % (key, value)
12726 
      for key, value in self.__dict__.iteritems()]
12727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12728 
 
12729 
  def __eq__(self, other):
12730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12731 
 
12732 
  def __ne__(self, other):
12733 
    return not (self == other)
12734 
 
12735 
class getNonDeliveredOrdersbyCourier_args:
12736 
  """
12737 
  Attributes:
12738 
   - providerId
12739 
  """
12740 
 
12741 
  thrift_spec = (
12742 
    None, # 0
12743 
    (1, TType.I64, 'providerId', None, None, ), # 1
12744 
  )
12745 
 
12746 
  def __init__(self, providerId=None,):
12747 
    self.providerId = providerId
12748 
 
12749 
  def read(self, iprot):
12750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12752 
      return
12753 
    iprot.readStructBegin()
12754 
    while True:
12755 
      (fname, ftype, fid) = iprot.readFieldBegin()
12756 
      if ftype == TType.STOP:
12757 
        break
12758 
      if fid == 1:
12759 
        if ftype == TType.I64:
12760 
          self.providerId = iprot.readI64();
12761 
        else:
12762 
          iprot.skip(ftype)
12763 
      else:
12764 
        iprot.skip(ftype)
12765 
      iprot.readFieldEnd()
12766 
    iprot.readStructEnd()
12767 
 
12768 
  def write(self, oprot):
12769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12771 
      return
12772 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
12773 
    if self.providerId is not None:
12774 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12775 
      oprot.writeI64(self.providerId)
12776 
      oprot.writeFieldEnd()
12777 
    oprot.writeFieldStop()
12778 
    oprot.writeStructEnd()
12779 
 
12780 
  def validate(self):
12781 
    return
12782 
 
12783 
 
12784 
  def __repr__(self):
12785 
    L = ['%s=%r' % (key, value)
12786 
      for key, value in self.__dict__.iteritems()]
12787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12788 
 
12789 
  def __eq__(self, other):
12790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12791 
 
12792 
  def __ne__(self, other):
12793 
    return not (self == other)
12794 
 
12795 
class getNonDeliveredOrdersbyCourier_result:
12796 
  """
12797 
  Attributes:
12798 
   - success
12799 
  """
12800 
 
12801 
  thrift_spec = (
12802 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12803 
  )
12804 
 
12805 
  def __init__(self, success=None,):
12806 
    self.success = success
12807 
 
12808 
  def read(self, iprot):
12809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12811 
      return
12812 
    iprot.readStructBegin()
12813 
    while True:
12814 
      (fname, ftype, fid) = iprot.readFieldBegin()
12815 
      if ftype == TType.STOP:
12816 
        break
4581 phani.kuma 12817 
      if fid == 0:
12818 
        if ftype == TType.LIST:
12819 
          self.success = []
5031 varun.gupt 12820 
          (_etype270, _size267) = iprot.readListBegin()
12821 
          for _i271 in xrange(_size267):
12822 
            _elem272 = Order()
12823 
            _elem272.read(iprot)
12824 
            self.success.append(_elem272)
4581 phani.kuma 12825 
          iprot.readListEnd()
12826 
        else:
12827 
          iprot.skip(ftype)
4910 phani.kuma 12828 
      else:
12829 
        iprot.skip(ftype)
12830 
      iprot.readFieldEnd()
12831 
    iprot.readStructEnd()
12832 
 
12833 
  def write(self, oprot):
12834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12836 
      return
12837 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
12838 
    if self.success is not None:
12839 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12840 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 12841 
      for iter273 in self.success:
12842 
        iter273.write(oprot)
4910 phani.kuma 12843 
      oprot.writeListEnd()
12844 
      oprot.writeFieldEnd()
12845 
    oprot.writeFieldStop()
12846 
    oprot.writeStructEnd()
12847 
 
12848 
  def validate(self):
12849 
    return
12850 
 
12851 
 
12852 
  def __repr__(self):
12853 
    L = ['%s=%r' % (key, value)
12854 
      for key, value in self.__dict__.iteritems()]
12855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12856 
 
12857 
  def __eq__(self, other):
12858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12859 
 
12860 
  def __ne__(self, other):
12861 
    return not (self == other)
12862 
 
12863 
class markOrdersAsLocalConnected_args:
12864 
  """
12865 
  Attributes:
12866 
   - providerId
12867 
   - local_connected_orders
12868 
  """
12869 
 
12870 
  thrift_spec = (
12871 
    None, # 0
12872 
    (1, TType.I64, 'providerId', None, None, ), # 1
12873 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
12874 
  )
12875 
 
12876 
  def __init__(self, providerId=None, local_connected_orders=None,):
12877 
    self.providerId = providerId
12878 
    self.local_connected_orders = local_connected_orders
12879 
 
12880 
  def read(self, iprot):
12881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12883 
      return
12884 
    iprot.readStructBegin()
12885 
    while True:
12886 
      (fname, ftype, fid) = iprot.readFieldBegin()
12887 
      if ftype == TType.STOP:
12888 
        break
12889 
      if fid == 1:
12890 
        if ftype == TType.I64:
12891 
          self.providerId = iprot.readI64();
12892 
        else:
12893 
          iprot.skip(ftype)
12894 
      elif fid == 2:
12895 
        if ftype == TType.MAP:
12896 
          self.local_connected_orders = {}
5031 varun.gupt 12897 
          (_ktype275, _vtype276, _size274 ) = iprot.readMapBegin()
12898 
          for _i278 in xrange(_size274):
12899 
            _key279 = iprot.readString();
12900 
            _val280 = iprot.readString();
12901 
            self.local_connected_orders[_key279] = _val280
4910 phani.kuma 12902 
          iprot.readMapEnd()
12903 
        else:
12904 
          iprot.skip(ftype)
12905 
      else:
12906 
        iprot.skip(ftype)
12907 
      iprot.readFieldEnd()
12908 
    iprot.readStructEnd()
12909 
 
12910 
  def write(self, oprot):
12911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12913 
      return
12914 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
12915 
    if self.providerId is not None:
12916 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12917 
      oprot.writeI64(self.providerId)
12918 
      oprot.writeFieldEnd()
12919 
    if self.local_connected_orders is not None:
12920 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
12921 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
5031 varun.gupt 12922 
      for kiter281,viter282 in self.local_connected_orders.items():
12923 
        oprot.writeString(kiter281)
12924 
        oprot.writeString(viter282)
4910 phani.kuma 12925 
      oprot.writeMapEnd()
12926 
      oprot.writeFieldEnd()
12927 
    oprot.writeFieldStop()
12928 
    oprot.writeStructEnd()
12929 
 
12930 
  def validate(self):
12931 
    return
12932 
 
12933 
 
12934 
  def __repr__(self):
12935 
    L = ['%s=%r' % (key, value)
12936 
      for key, value in self.__dict__.iteritems()]
12937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12938 
 
12939 
  def __eq__(self, other):
12940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12941 
 
12942 
  def __ne__(self, other):
12943 
    return not (self == other)
12944 
 
12945 
class markOrdersAsLocalConnected_result:
12946 
  """
12947 
  Attributes:
12948 
   - ex
12949 
  """
12950 
 
12951 
  thrift_spec = (
12952 
    None, # 0
12953 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12954 
  )
12955 
 
12956 
  def __init__(self, ex=None,):
12957 
    self.ex = ex
12958 
 
12959 
  def read(self, iprot):
12960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12962 
      return
12963 
    iprot.readStructBegin()
12964 
    while True:
12965 
      (fname, ftype, fid) = iprot.readFieldBegin()
12966 
      if ftype == TType.STOP:
12967 
        break
12968 
      if fid == 1:
3064 chandransh 12969 
        if ftype == TType.STRUCT:
12970 
          self.ex = TransactionServiceException()
12971 
          self.ex.read(iprot)
1627 ankur.sing 12972 
        else:
12973 
          iprot.skip(ftype)
12974 
      else:
12975 
        iprot.skip(ftype)
12976 
      iprot.readFieldEnd()
12977 
    iprot.readStructEnd()
12978 
 
12979 
  def write(self, oprot):
12980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12982 
      return
4910 phani.kuma 12983 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
12984 
    if self.ex is not None:
12985 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12986 
      self.ex.write(oprot)
12987 
      oprot.writeFieldEnd()
12988 
    oprot.writeFieldStop()
12989 
    oprot.writeStructEnd()
12990 
 
12991 
  def validate(self):
12992 
    return
12993 
 
12994 
 
12995 
  def __repr__(self):
12996 
    L = ['%s=%r' % (key, value)
12997 
      for key, value in self.__dict__.iteritems()]
12998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12999 
 
13000 
  def __eq__(self, other):
13001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13002 
 
13003 
  def __ne__(self, other):
13004 
    return not (self == other)
13005 
 
13006 
class getOrdersNotLocalConnected_args:
13007 
  """
13008 
  Attributes:
13009 
   - providerId
13010 
  """
13011 
 
13012 
  thrift_spec = (
13013 
    None, # 0
13014 
    (1, TType.I64, 'providerId', None, None, ), # 1
13015 
  )
13016 
 
13017 
  def __init__(self, providerId=None,):
13018 
    self.providerId = providerId
13019 
 
13020 
  def read(self, iprot):
13021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13023 
      return
13024 
    iprot.readStructBegin()
13025 
    while True:
13026 
      (fname, ftype, fid) = iprot.readFieldBegin()
13027 
      if ftype == TType.STOP:
13028 
        break
13029 
      if fid == 1:
13030 
        if ftype == TType.I64:
13031 
          self.providerId = iprot.readI64();
13032 
        else:
13033 
          iprot.skip(ftype)
13034 
      else:
13035 
        iprot.skip(ftype)
13036 
      iprot.readFieldEnd()
13037 
    iprot.readStructEnd()
13038 
 
13039 
  def write(self, oprot):
13040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13042 
      return
13043 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
13044 
    if self.providerId is not None:
13045 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13046 
      oprot.writeI64(self.providerId)
13047 
      oprot.writeFieldEnd()
13048 
    oprot.writeFieldStop()
13049 
    oprot.writeStructEnd()
13050 
 
13051 
  def validate(self):
13052 
    return
13053 
 
13054 
 
13055 
  def __repr__(self):
13056 
    L = ['%s=%r' % (key, value)
13057 
      for key, value in self.__dict__.iteritems()]
13058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13059 
 
13060 
  def __eq__(self, other):
13061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13062 
 
13063 
  def __ne__(self, other):
13064 
    return not (self == other)
13065 
 
13066 
class getOrdersNotLocalConnected_result:
13067 
  """
13068 
  Attributes:
13069 
   - success
13070 
  """
13071 
 
13072 
  thrift_spec = (
13073 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13074 
  )
13075 
 
13076 
  def __init__(self, success=None,):
13077 
    self.success = success
13078 
 
13079 
  def read(self, iprot):
13080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13082 
      return
13083 
    iprot.readStructBegin()
13084 
    while True:
13085 
      (fname, ftype, fid) = iprot.readFieldBegin()
13086 
      if ftype == TType.STOP:
13087 
        break
13088 
      if fid == 0:
13089 
        if ftype == TType.LIST:
13090 
          self.success = []
5031 varun.gupt 13091 
          (_etype286, _size283) = iprot.readListBegin()
13092 
          for _i287 in xrange(_size283):
13093 
            _elem288 = Order()
13094 
            _elem288.read(iprot)
13095 
            self.success.append(_elem288)
4910 phani.kuma 13096 
          iprot.readListEnd()
13097 
        else:
13098 
          iprot.skip(ftype)
13099 
      else:
13100 
        iprot.skip(ftype)
13101 
      iprot.readFieldEnd()
13102 
    iprot.readStructEnd()
13103 
 
13104 
  def write(self, oprot):
13105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13107 
      return
13108 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 13109 
    if self.success is not None:
13110 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13111 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13112 
      for iter289 in self.success:
13113 
        iter289.write(oprot)
4581 phani.kuma 13114 
      oprot.writeListEnd()
13115 
      oprot.writeFieldEnd()
4910 phani.kuma 13116 
    oprot.writeFieldStop()
13117 
    oprot.writeStructEnd()
13118 
 
13119 
  def validate(self):
13120 
    return
13121 
 
13122 
 
13123 
  def __repr__(self):
13124 
    L = ['%s=%r' % (key, value)
13125 
      for key, value in self.__dict__.iteritems()]
13126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13127 
 
13128 
  def __eq__(self, other):
13129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13130 
 
13131 
  def __ne__(self, other):
13132 
    return not (self == other)
13133 
 
13134 
class markOrdersAsDestinationCityReached_args:
13135 
  """
13136 
  Attributes:
13137 
   - providerId
13138 
   - destination_city_reached_orders
13139 
  """
13140 
 
13141 
  thrift_spec = (
13142 
    None, # 0
13143 
    (1, TType.I64, 'providerId', None, None, ), # 1
13144 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13145 
  )
13146 
 
13147 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
13148 
    self.providerId = providerId
13149 
    self.destination_city_reached_orders = destination_city_reached_orders
13150 
 
13151 
  def read(self, iprot):
13152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13154 
      return
13155 
    iprot.readStructBegin()
13156 
    while True:
13157 
      (fname, ftype, fid) = iprot.readFieldBegin()
13158 
      if ftype == TType.STOP:
13159 
        break
13160 
      if fid == 1:
13161 
        if ftype == TType.I64:
13162 
          self.providerId = iprot.readI64();
13163 
        else:
13164 
          iprot.skip(ftype)
13165 
      elif fid == 2:
13166 
        if ftype == TType.MAP:
13167 
          self.destination_city_reached_orders = {}
5031 varun.gupt 13168 
          (_ktype291, _vtype292, _size290 ) = iprot.readMapBegin()
13169 
          for _i294 in xrange(_size290):
13170 
            _key295 = iprot.readString();
13171 
            _val296 = iprot.readString();
13172 
            self.destination_city_reached_orders[_key295] = _val296
4910 phani.kuma 13173 
          iprot.readMapEnd()
13174 
        else:
13175 
          iprot.skip(ftype)
13176 
      else:
13177 
        iprot.skip(ftype)
13178 
      iprot.readFieldEnd()
13179 
    iprot.readStructEnd()
13180 
 
13181 
  def write(self, oprot):
13182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13184 
      return
13185 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
13186 
    if self.providerId is not None:
13187 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13188 
      oprot.writeI64(self.providerId)
13189 
      oprot.writeFieldEnd()
13190 
    if self.destination_city_reached_orders is not None:
13191 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
13192 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
5031 varun.gupt 13193 
      for kiter297,viter298 in self.destination_city_reached_orders.items():
13194 
        oprot.writeString(kiter297)
13195 
        oprot.writeString(viter298)
4910 phani.kuma 13196 
      oprot.writeMapEnd()
13197 
      oprot.writeFieldEnd()
13198 
    oprot.writeFieldStop()
13199 
    oprot.writeStructEnd()
13200 
 
13201 
  def validate(self):
13202 
    return
13203 
 
13204 
 
13205 
  def __repr__(self):
13206 
    L = ['%s=%r' % (key, value)
13207 
      for key, value in self.__dict__.iteritems()]
13208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13209 
 
13210 
  def __eq__(self, other):
13211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13212 
 
13213 
  def __ne__(self, other):
13214 
    return not (self == other)
13215 
 
13216 
class markOrdersAsDestinationCityReached_result:
13217 
  """
13218 
  Attributes:
13219 
   - ex
13220 
  """
13221 
 
13222 
  thrift_spec = (
13223 
    None, # 0
13224 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13225 
  )
13226 
 
13227 
  def __init__(self, ex=None,):
13228 
    self.ex = ex
13229 
 
13230 
  def read(self, iprot):
13231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13233 
      return
13234 
    iprot.readStructBegin()
13235 
    while True:
13236 
      (fname, ftype, fid) = iprot.readFieldBegin()
13237 
      if ftype == TType.STOP:
13238 
        break
13239 
      if fid == 1:
13240 
        if ftype == TType.STRUCT:
13241 
          self.ex = TransactionServiceException()
13242 
          self.ex.read(iprot)
13243 
        else:
13244 
          iprot.skip(ftype)
13245 
      else:
13246 
        iprot.skip(ftype)
13247 
      iprot.readFieldEnd()
13248 
    iprot.readStructEnd()
13249 
 
13250 
  def write(self, oprot):
13251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13253 
      return
13254 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 13255 
    if self.ex is not None:
3064 chandransh 13256 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13257 
      self.ex.write(oprot)
1627 ankur.sing 13258 
      oprot.writeFieldEnd()
13259 
    oprot.writeFieldStop()
13260 
    oprot.writeStructEnd()
13261 
 
3431 rajveer 13262 
  def validate(self):
13263 
    return
13264 
 
13265 
 
1627 ankur.sing 13266 
  def __repr__(self):
13267 
    L = ['%s=%r' % (key, value)
13268 
      for key, value in self.__dict__.iteritems()]
13269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13270 
 
13271 
  def __eq__(self, other):
13272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13273 
 
13274 
  def __ne__(self, other):
13275 
    return not (self == other)
13276 
 
4910 phani.kuma 13277 
class markOrdersAsFirstDeliveryAttempted_args:
13278 
  """
13279 
  Attributes:
13280 
   - providerId
13281 
   - first_atdl_orders
13282 
  """
13283 
 
13284 
  thrift_spec = (
13285 
    None, # 0
13286 
    (1, TType.I64, 'providerId', None, None, ), # 1
13287 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
13288 
  )
13289 
 
13290 
  def __init__(self, providerId=None, first_atdl_orders=None,):
13291 
    self.providerId = providerId
13292 
    self.first_atdl_orders = first_atdl_orders
13293 
 
13294 
  def read(self, iprot):
13295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13297 
      return
13298 
    iprot.readStructBegin()
13299 
    while True:
13300 
      (fname, ftype, fid) = iprot.readFieldBegin()
13301 
      if ftype == TType.STOP:
13302 
        break
13303 
      if fid == 1:
13304 
        if ftype == TType.I64:
13305 
          self.providerId = iprot.readI64();
13306 
        else:
13307 
          iprot.skip(ftype)
13308 
      elif fid == 2:
13309 
        if ftype == TType.MAP:
13310 
          self.first_atdl_orders = {}
5031 varun.gupt 13311 
          (_ktype300, _vtype301, _size299 ) = iprot.readMapBegin()
13312 
          for _i303 in xrange(_size299):
13313 
            _key304 = iprot.readString();
13314 
            _val305 = iprot.readString();
13315 
            self.first_atdl_orders[_key304] = _val305
4910 phani.kuma 13316 
          iprot.readMapEnd()
13317 
        else:
13318 
          iprot.skip(ftype)
13319 
      else:
13320 
        iprot.skip(ftype)
13321 
      iprot.readFieldEnd()
13322 
    iprot.readStructEnd()
13323 
 
13324 
  def write(self, oprot):
13325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13327 
      return
13328 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
13329 
    if self.providerId is not None:
13330 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13331 
      oprot.writeI64(self.providerId)
13332 
      oprot.writeFieldEnd()
13333 
    if self.first_atdl_orders is not None:
13334 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
13335 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
5031 varun.gupt 13336 
      for kiter306,viter307 in self.first_atdl_orders.items():
13337 
        oprot.writeString(kiter306)
13338 
        oprot.writeString(viter307)
4910 phani.kuma 13339 
      oprot.writeMapEnd()
13340 
      oprot.writeFieldEnd()
13341 
    oprot.writeFieldStop()
13342 
    oprot.writeStructEnd()
13343 
 
13344 
  def validate(self):
13345 
    return
13346 
 
13347 
 
13348 
  def __repr__(self):
13349 
    L = ['%s=%r' % (key, value)
13350 
      for key, value in self.__dict__.iteritems()]
13351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13352 
 
13353 
  def __eq__(self, other):
13354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13355 
 
13356 
  def __ne__(self, other):
13357 
    return not (self == other)
13358 
 
13359 
class markOrdersAsFirstDeliveryAttempted_result:
13360 
  """
13361 
  Attributes:
13362 
   - ex
13363 
  """
13364 
 
13365 
  thrift_spec = (
13366 
    None, # 0
13367 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13368 
  )
13369 
 
13370 
  def __init__(self, ex=None,):
13371 
    self.ex = ex
13372 
 
13373 
  def read(self, iprot):
13374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13376 
      return
13377 
    iprot.readStructBegin()
13378 
    while True:
13379 
      (fname, ftype, fid) = iprot.readFieldBegin()
13380 
      if ftype == TType.STOP:
13381 
        break
13382 
      if fid == 1:
13383 
        if ftype == TType.STRUCT:
13384 
          self.ex = TransactionServiceException()
13385 
          self.ex.read(iprot)
13386 
        else:
13387 
          iprot.skip(ftype)
13388 
      else:
13389 
        iprot.skip(ftype)
13390 
      iprot.readFieldEnd()
13391 
    iprot.readStructEnd()
13392 
 
13393 
  def write(self, oprot):
13394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13396 
      return
13397 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
13398 
    if self.ex is not None:
13399 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13400 
      self.ex.write(oprot)
13401 
      oprot.writeFieldEnd()
13402 
    oprot.writeFieldStop()
13403 
    oprot.writeStructEnd()
13404 
 
13405 
  def validate(self):
13406 
    return
13407 
 
13408 
 
13409 
  def __repr__(self):
13410 
    L = ['%s=%r' % (key, value)
13411 
      for key, value in self.__dict__.iteritems()]
13412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13413 
 
13414 
  def __eq__(self, other):
13415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13416 
 
13417 
  def __ne__(self, other):
13418 
    return not (self == other)
13419 
 
3064 chandransh 13420 
class getUndeliveredOrders_args:
1886 ankur.sing 13421 
  """
13422 
  Attributes:
3064 chandransh 13423 
   - providerId
13424 
   - warehouseId
1886 ankur.sing 13425 
  """
1627 ankur.sing 13426 
 
1886 ankur.sing 13427 
  thrift_spec = (
13428 
    None, # 0
3064 chandransh 13429 
    (1, TType.I64, 'providerId', None, None, ), # 1
13430 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 13431 
  )
13432 
 
3064 chandransh 13433 
  def __init__(self, providerId=None, warehouseId=None,):
13434 
    self.providerId = providerId
13435 
    self.warehouseId = warehouseId
1886 ankur.sing 13436 
 
13437 
  def read(self, iprot):
13438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13440 
      return
13441 
    iprot.readStructBegin()
13442 
    while True:
13443 
      (fname, ftype, fid) = iprot.readFieldBegin()
13444 
      if ftype == TType.STOP:
13445 
        break
13446 
      if fid == 1:
13447 
        if ftype == TType.I64:
3064 chandransh 13448 
          self.providerId = iprot.readI64();
1886 ankur.sing 13449 
        else:
13450 
          iprot.skip(ftype)
3064 chandransh 13451 
      elif fid == 2:
13452 
        if ftype == TType.I64:
13453 
          self.warehouseId = iprot.readI64();
13454 
        else:
13455 
          iprot.skip(ftype)
1886 ankur.sing 13456 
      else:
13457 
        iprot.skip(ftype)
13458 
      iprot.readFieldEnd()
13459 
    iprot.readStructEnd()
13460 
 
13461 
  def write(self, oprot):
13462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13464 
      return
3064 chandransh 13465 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 13466 
    if self.providerId is not None:
3064 chandransh 13467 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13468 
      oprot.writeI64(self.providerId)
1886 ankur.sing 13469 
      oprot.writeFieldEnd()
3431 rajveer 13470 
    if self.warehouseId is not None:
3064 chandransh 13471 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13472 
      oprot.writeI64(self.warehouseId)
13473 
      oprot.writeFieldEnd()
1886 ankur.sing 13474 
    oprot.writeFieldStop()
13475 
    oprot.writeStructEnd()
13476 
 
3431 rajveer 13477 
  def validate(self):
13478 
    return
13479 
 
13480 
 
1886 ankur.sing 13481 
  def __repr__(self):
13482 
    L = ['%s=%r' % (key, value)
13483 
      for key, value in self.__dict__.iteritems()]
13484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13485 
 
13486 
  def __eq__(self, other):
13487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13488 
 
13489 
  def __ne__(self, other):
13490 
    return not (self == other)
13491 
 
3064 chandransh 13492 
class getUndeliveredOrders_result:
1886 ankur.sing 13493 
  """
13494 
  Attributes:
13495 
   - success
13496 
  """
13497 
 
13498 
  thrift_spec = (
13499 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13500 
  )
13501 
 
13502 
  def __init__(self, success=None,):
13503 
    self.success = success
13504 
 
13505 
  def read(self, iprot):
13506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13508 
      return
13509 
    iprot.readStructBegin()
13510 
    while True:
13511 
      (fname, ftype, fid) = iprot.readFieldBegin()
13512 
      if ftype == TType.STOP:
13513 
        break
13514 
      if fid == 0:
13515 
        if ftype == TType.LIST:
13516 
          self.success = []
5031 varun.gupt 13517 
          (_etype311, _size308) = iprot.readListBegin()
13518 
          for _i312 in xrange(_size308):
13519 
            _elem313 = Order()
13520 
            _elem313.read(iprot)
13521 
            self.success.append(_elem313)
1886 ankur.sing 13522 
          iprot.readListEnd()
13523 
        else:
13524 
          iprot.skip(ftype)
13525 
      else:
13526 
        iprot.skip(ftype)
13527 
      iprot.readFieldEnd()
13528 
    iprot.readStructEnd()
13529 
 
13530 
  def write(self, oprot):
13531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13533 
      return
3064 chandransh 13534 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 13535 
    if self.success is not None:
1886 ankur.sing 13536 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13537 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13538 
      for iter314 in self.success:
13539 
        iter314.write(oprot)
1886 ankur.sing 13540 
      oprot.writeListEnd()
13541 
      oprot.writeFieldEnd()
13542 
    oprot.writeFieldStop()
13543 
    oprot.writeStructEnd()
13544 
 
3431 rajveer 13545 
  def validate(self):
13546 
    return
13547 
 
13548 
 
1886 ankur.sing 13549 
  def __repr__(self):
13550 
    L = ['%s=%r' % (key, value)
13551 
      for key, value in self.__dict__.iteritems()]
13552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13553 
 
13554 
  def __eq__(self, other):
13555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13556 
 
13557 
  def __ne__(self, other):
13558 
    return not (self == other)
13559 
 
4783 phani.kuma 13560 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
13561 
 
13562 
  thrift_spec = (
13563 
  )
13564 
 
13565 
  def read(self, iprot):
13566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13568 
      return
13569 
    iprot.readStructBegin()
13570 
    while True:
13571 
      (fname, ftype, fid) = iprot.readFieldBegin()
13572 
      if ftype == TType.STOP:
13573 
        break
13574 
      else:
13575 
        iprot.skip(ftype)
13576 
      iprot.readFieldEnd()
13577 
    iprot.readStructEnd()
13578 
 
13579 
  def write(self, oprot):
13580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13582 
      return
13583 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
13584 
    oprot.writeFieldStop()
13585 
    oprot.writeStructEnd()
13586 
 
13587 
  def validate(self):
13588 
    return
13589 
 
13590 
 
13591 
  def __repr__(self):
13592 
    L = ['%s=%r' % (key, value)
13593 
      for key, value in self.__dict__.iteritems()]
13594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13595 
 
13596 
  def __eq__(self, other):
13597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13598 
 
13599 
  def __ne__(self, other):
13600 
    return not (self == other)
13601 
 
13602 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
13603 
  """
13604 
  Attributes:
13605 
   - success
13606 
  """
13607 
 
13608 
  thrift_spec = (
13609 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13610 
  )
13611 
 
13612 
  def __init__(self, success=None,):
13613 
    self.success = success
13614 
 
13615 
  def read(self, iprot):
13616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13618 
      return
13619 
    iprot.readStructBegin()
13620 
    while True:
13621 
      (fname, ftype, fid) = iprot.readFieldBegin()
13622 
      if ftype == TType.STOP:
13623 
        break
13624 
      if fid == 0:
13625 
        if ftype == TType.LIST:
13626 
          self.success = []
5031 varun.gupt 13627 
          (_etype318, _size315) = iprot.readListBegin()
13628 
          for _i319 in xrange(_size315):
13629 
            _elem320 = Order()
13630 
            _elem320.read(iprot)
13631 
            self.success.append(_elem320)
4783 phani.kuma 13632 
          iprot.readListEnd()
13633 
        else:
13634 
          iprot.skip(ftype)
13635 
      else:
13636 
        iprot.skip(ftype)
13637 
      iprot.readFieldEnd()
13638 
    iprot.readStructEnd()
13639 
 
13640 
  def write(self, oprot):
13641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13643 
      return
13644 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
13645 
    if self.success is not None:
13646 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13647 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 13648 
      for iter321 in self.success:
13649 
        iter321.write(oprot)
4783 phani.kuma 13650 
      oprot.writeListEnd()
13651 
      oprot.writeFieldEnd()
13652 
    oprot.writeFieldStop()
13653 
    oprot.writeStructEnd()
13654 
 
13655 
  def validate(self):
13656 
    return
13657 
 
13658 
 
13659 
  def __repr__(self):
13660 
    L = ['%s=%r' % (key, value)
13661 
      for key, value in self.__dict__.iteritems()]
13662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13663 
 
13664 
  def __eq__(self, other):
13665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13666 
 
13667 
  def __ne__(self, other):
13668 
    return not (self == other)
13669 
 
2536 chandransh 13670 
class toggleDOAFlag_args:
13671 
  """
13672 
  Attributes:
13673 
   - orderId
13674 
  """
1886 ankur.sing 13675 
 
2536 chandransh 13676 
  thrift_spec = (
13677 
    None, # 0
13678 
    (1, TType.I64, 'orderId', None, None, ), # 1
13679 
  )
13680 
 
13681 
  def __init__(self, orderId=None,):
13682 
    self.orderId = orderId
13683 
 
13684 
  def read(self, iprot):
13685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13687 
      return
13688 
    iprot.readStructBegin()
13689 
    while True:
13690 
      (fname, ftype, fid) = iprot.readFieldBegin()
13691 
      if ftype == TType.STOP:
13692 
        break
13693 
      if fid == 1:
13694 
        if ftype == TType.I64:
13695 
          self.orderId = iprot.readI64();
13696 
        else:
13697 
          iprot.skip(ftype)
13698 
      else:
13699 
        iprot.skip(ftype)
13700 
      iprot.readFieldEnd()
13701 
    iprot.readStructEnd()
13702 
 
13703 
  def write(self, oprot):
13704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13706 
      return
13707 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 13708 
    if self.orderId is not None:
2536 chandransh 13709 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13710 
      oprot.writeI64(self.orderId)
13711 
      oprot.writeFieldEnd()
13712 
    oprot.writeFieldStop()
13713 
    oprot.writeStructEnd()
13714 
 
3431 rajveer 13715 
  def validate(self):
13716 
    return
13717 
 
13718 
 
2536 chandransh 13719 
  def __repr__(self):
13720 
    L = ['%s=%r' % (key, value)
13721 
      for key, value in self.__dict__.iteritems()]
13722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13723 
 
13724 
  def __eq__(self, other):
13725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13726 
 
13727 
  def __ne__(self, other):
13728 
    return not (self == other)
13729 
 
13730 
class toggleDOAFlag_result:
13731 
  """
13732 
  Attributes:
13733 
   - success
13734 
   - ex
13735 
  """
13736 
 
13737 
  thrift_spec = (
13738 
    (0, TType.BOOL, 'success', None, None, ), # 0
13739 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13740 
  )
13741 
 
13742 
  def __init__(self, success=None, ex=None,):
13743 
    self.success = success
13744 
    self.ex = ex
13745 
 
13746 
  def read(self, iprot):
13747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13749 
      return
13750 
    iprot.readStructBegin()
13751 
    while True:
13752 
      (fname, ftype, fid) = iprot.readFieldBegin()
13753 
      if ftype == TType.STOP:
13754 
        break
13755 
      if fid == 0:
13756 
        if ftype == TType.BOOL:
13757 
          self.success = iprot.readBool();
13758 
        else:
13759 
          iprot.skip(ftype)
13760 
      elif fid == 1:
13761 
        if ftype == TType.STRUCT:
13762 
          self.ex = TransactionServiceException()
13763 
          self.ex.read(iprot)
13764 
        else:
13765 
          iprot.skip(ftype)
13766 
      else:
13767 
        iprot.skip(ftype)
13768 
      iprot.readFieldEnd()
13769 
    iprot.readStructEnd()
13770 
 
13771 
  def write(self, oprot):
13772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13774 
      return
13775 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 13776 
    if self.success is not None:
2536 chandransh 13777 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13778 
      oprot.writeBool(self.success)
13779 
      oprot.writeFieldEnd()
3431 rajveer 13780 
    if self.ex is not None:
2536 chandransh 13781 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13782 
      self.ex.write(oprot)
13783 
      oprot.writeFieldEnd()
13784 
    oprot.writeFieldStop()
13785 
    oprot.writeStructEnd()
13786 
 
3431 rajveer 13787 
  def validate(self):
13788 
    return
13789 
 
13790 
 
2536 chandransh 13791 
  def __repr__(self):
13792 
    L = ['%s=%r' % (key, value)
13793 
      for key, value in self.__dict__.iteritems()]
13794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13795 
 
13796 
  def __eq__(self, other):
13797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13798 
 
13799 
  def __ne__(self, other):
13800 
    return not (self == other)
13801 
 
4712 rajveer 13802 
class markOrderAsDelivered_args:
13803 
  """
13804 
  Attributes:
13805 
   - orderId
13806 
   - deliveryTimestamp
13807 
   - receiver
13808 
  """
13809 
 
13810 
  thrift_spec = None
13811 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
13812 
    self.orderId = orderId
13813 
    self.deliveryTimestamp = deliveryTimestamp
13814 
    self.receiver = receiver
13815 
 
13816 
  def read(self, iprot):
13817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13819 
      return
13820 
    iprot.readStructBegin()
13821 
    while True:
13822 
      (fname, ftype, fid) = iprot.readFieldBegin()
13823 
      if ftype == TType.STOP:
13824 
        break
13825 
      if fid == 1:
13826 
        if ftype == TType.I64:
13827 
          self.orderId = iprot.readI64();
13828 
        else:
13829 
          iprot.skip(ftype)
13830 
      elif fid == 2:
13831 
        if ftype == TType.I64:
13832 
          self.deliveryTimestamp = iprot.readI64();
13833 
        else:
13834 
          iprot.skip(ftype)
13835 
      elif fid == -1:
13836 
        if ftype == TType.STRING:
13837 
          self.receiver = iprot.readString();
13838 
        else:
13839 
          iprot.skip(ftype)
13840 
      else:
13841 
        iprot.skip(ftype)
13842 
      iprot.readFieldEnd()
13843 
    iprot.readStructEnd()
13844 
 
13845 
  def write(self, oprot):
13846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13848 
      return
13849 
    oprot.writeStructBegin('markOrderAsDelivered_args')
13850 
    if self.receiver is not None:
13851 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
13852 
      oprot.writeString(self.receiver)
13853 
      oprot.writeFieldEnd()
13854 
    if self.orderId is not None:
13855 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13856 
      oprot.writeI64(self.orderId)
13857 
      oprot.writeFieldEnd()
13858 
    if self.deliveryTimestamp is not None:
13859 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
13860 
      oprot.writeI64(self.deliveryTimestamp)
13861 
      oprot.writeFieldEnd()
13862 
    oprot.writeFieldStop()
13863 
    oprot.writeStructEnd()
13864 
 
13865 
  def validate(self):
13866 
    return
13867 
 
13868 
 
13869 
  def __repr__(self):
13870 
    L = ['%s=%r' % (key, value)
13871 
      for key, value in self.__dict__.iteritems()]
13872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13873 
 
13874 
  def __eq__(self, other):
13875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13876 
 
13877 
  def __ne__(self, other):
13878 
    return not (self == other)
13879 
 
13880 
class markOrderAsDelivered_result:
13881 
  """
13882 
  Attributes:
13883 
   - ex
13884 
  """
13885 
 
13886 
  thrift_spec = (
13887 
    None, # 0
13888 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13889 
  )
13890 
 
13891 
  def __init__(self, ex=None,):
13892 
    self.ex = ex
13893 
 
13894 
  def read(self, iprot):
13895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13897 
      return
13898 
    iprot.readStructBegin()
13899 
    while True:
13900 
      (fname, ftype, fid) = iprot.readFieldBegin()
13901 
      if ftype == TType.STOP:
13902 
        break
13903 
      if fid == 1:
13904 
        if ftype == TType.STRUCT:
13905 
          self.ex = TransactionServiceException()
13906 
          self.ex.read(iprot)
13907 
        else:
13908 
          iprot.skip(ftype)
13909 
      else:
13910 
        iprot.skip(ftype)
13911 
      iprot.readFieldEnd()
13912 
    iprot.readStructEnd()
13913 
 
13914 
  def write(self, oprot):
13915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13917 
      return
13918 
    oprot.writeStructBegin('markOrderAsDelivered_result')
13919 
    if self.ex is not None:
13920 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13921 
      self.ex.write(oprot)
13922 
      oprot.writeFieldEnd()
13923 
    oprot.writeFieldStop()
13924 
    oprot.writeStructEnd()
13925 
 
13926 
  def validate(self):
13927 
    return
13928 
 
13929 
 
13930 
  def __repr__(self):
13931 
    L = ['%s=%r' % (key, value)
13932 
      for key, value in self.__dict__.iteritems()]
13933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13934 
 
13935 
  def __eq__(self, other):
13936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13937 
 
13938 
  def __ne__(self, other):
13939 
    return not (self == other)
13940 
 
4454 rajveer 13941 
class markOrderDoaRequestReceived_args:
13942 
  """
13943 
  Attributes:
13944 
   - orderId
13945 
  """
13946 
 
13947 
  thrift_spec = (
13948 
    None, # 0
13949 
    (1, TType.I64, 'orderId', None, None, ), # 1
13950 
  )
13951 
 
13952 
  def __init__(self, orderId=None,):
13953 
    self.orderId = orderId
13954 
 
13955 
  def read(self, iprot):
13956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13958 
      return
13959 
    iprot.readStructBegin()
13960 
    while True:
13961 
      (fname, ftype, fid) = iprot.readFieldBegin()
13962 
      if ftype == TType.STOP:
13963 
        break
13964 
      if fid == 1:
13965 
        if ftype == TType.I64:
13966 
          self.orderId = iprot.readI64();
13967 
        else:
13968 
          iprot.skip(ftype)
13969 
      else:
13970 
        iprot.skip(ftype)
13971 
      iprot.readFieldEnd()
13972 
    iprot.readStructEnd()
13973 
 
13974 
  def write(self, oprot):
13975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13977 
      return
13978 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
13979 
    if self.orderId is not None:
13980 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13981 
      oprot.writeI64(self.orderId)
13982 
      oprot.writeFieldEnd()
13983 
    oprot.writeFieldStop()
13984 
    oprot.writeStructEnd()
13985 
 
13986 
  def validate(self):
13987 
    return
13988 
 
13989 
 
13990 
  def __repr__(self):
13991 
    L = ['%s=%r' % (key, value)
13992 
      for key, value in self.__dict__.iteritems()]
13993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13994 
 
13995 
  def __eq__(self, other):
13996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13997 
 
13998 
  def __ne__(self, other):
13999 
    return not (self == other)
14000 
 
14001 
class markOrderDoaRequestReceived_result:
14002 
  """
14003 
  Attributes:
14004 
   - success
14005 
   - ex
14006 
  """
14007 
 
14008 
  thrift_spec = (
14009 
    (0, TType.BOOL, 'success', None, None, ), # 0
14010 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14011 
  )
14012 
 
14013 
  def __init__(self, success=None, ex=None,):
14014 
    self.success = success
14015 
    self.ex = ex
14016 
 
14017 
  def read(self, iprot):
14018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14020 
      return
14021 
    iprot.readStructBegin()
14022 
    while True:
14023 
      (fname, ftype, fid) = iprot.readFieldBegin()
14024 
      if ftype == TType.STOP:
14025 
        break
14026 
      if fid == 0:
14027 
        if ftype == TType.BOOL:
14028 
          self.success = iprot.readBool();
14029 
        else:
14030 
          iprot.skip(ftype)
14031 
      elif fid == 1:
14032 
        if ftype == TType.STRUCT:
14033 
          self.ex = TransactionServiceException()
14034 
          self.ex.read(iprot)
14035 
        else:
14036 
          iprot.skip(ftype)
14037 
      else:
14038 
        iprot.skip(ftype)
14039 
      iprot.readFieldEnd()
14040 
    iprot.readStructEnd()
14041 
 
14042 
  def write(self, oprot):
14043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14045 
      return
14046 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
14047 
    if self.success is not None:
14048 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14049 
      oprot.writeBool(self.success)
14050 
      oprot.writeFieldEnd()
14051 
    if self.ex is not None:
14052 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14053 
      self.ex.write(oprot)
14054 
      oprot.writeFieldEnd()
14055 
    oprot.writeFieldStop()
14056 
    oprot.writeStructEnd()
14057 
 
14058 
  def validate(self):
14059 
    return
14060 
 
14061 
 
14062 
  def __repr__(self):
14063 
    L = ['%s=%r' % (key, value)
14064 
      for key, value in self.__dict__.iteritems()]
14065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14066 
 
14067 
  def __eq__(self, other):
14068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14069 
 
14070 
  def __ne__(self, other):
14071 
    return not (self == other)
14072 
 
14073 
class markOrderDoaRequestAuthorized_args:
14074 
  """
14075 
  Attributes:
14076 
   - orderId
14077 
   - isAuthorized
14078 
  """
14079 
 
14080 
  thrift_spec = (
14081 
    None, # 0
14082 
    (1, TType.I64, 'orderId', None, None, ), # 1
14083 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14084 
  )
14085 
 
14086 
  def __init__(self, orderId=None, isAuthorized=None,):
14087 
    self.orderId = orderId
14088 
    self.isAuthorized = isAuthorized
14089 
 
14090 
  def read(self, iprot):
14091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14093 
      return
14094 
    iprot.readStructBegin()
14095 
    while True:
14096 
      (fname, ftype, fid) = iprot.readFieldBegin()
14097 
      if ftype == TType.STOP:
14098 
        break
14099 
      if fid == 1:
14100 
        if ftype == TType.I64:
14101 
          self.orderId = iprot.readI64();
14102 
        else:
14103 
          iprot.skip(ftype)
14104 
      elif fid == 2:
14105 
        if ftype == TType.BOOL:
14106 
          self.isAuthorized = iprot.readBool();
14107 
        else:
14108 
          iprot.skip(ftype)
14109 
      else:
14110 
        iprot.skip(ftype)
14111 
      iprot.readFieldEnd()
14112 
    iprot.readStructEnd()
14113 
 
14114 
  def write(self, oprot):
14115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14117 
      return
14118 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
14119 
    if self.orderId is not None:
14120 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14121 
      oprot.writeI64(self.orderId)
14122 
      oprot.writeFieldEnd()
14123 
    if self.isAuthorized is not None:
14124 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14125 
      oprot.writeBool(self.isAuthorized)
14126 
      oprot.writeFieldEnd()
14127 
    oprot.writeFieldStop()
14128 
    oprot.writeStructEnd()
14129 
 
14130 
  def validate(self):
14131 
    return
14132 
 
14133 
 
14134 
  def __repr__(self):
14135 
    L = ['%s=%r' % (key, value)
14136 
      for key, value in self.__dict__.iteritems()]
14137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14138 
 
14139 
  def __eq__(self, other):
14140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14141 
 
14142 
  def __ne__(self, other):
14143 
    return not (self == other)
14144 
 
14145 
class markOrderDoaRequestAuthorized_result:
14146 
  """
14147 
  Attributes:
14148 
   - success
14149 
   - ex
14150 
  """
14151 
 
14152 
  thrift_spec = (
14153 
    (0, TType.BOOL, 'success', None, None, ), # 0
14154 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14155 
  )
14156 
 
14157 
  def __init__(self, success=None, ex=None,):
14158 
    self.success = success
14159 
    self.ex = ex
14160 
 
14161 
  def read(self, iprot):
14162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14164 
      return
14165 
    iprot.readStructBegin()
14166 
    while True:
14167 
      (fname, ftype, fid) = iprot.readFieldBegin()
14168 
      if ftype == TType.STOP:
14169 
        break
14170 
      if fid == 0:
14171 
        if ftype == TType.BOOL:
14172 
          self.success = iprot.readBool();
14173 
        else:
14174 
          iprot.skip(ftype)
14175 
      elif fid == 1:
14176 
        if ftype == TType.STRUCT:
14177 
          self.ex = TransactionServiceException()
14178 
          self.ex.read(iprot)
14179 
        else:
14180 
          iprot.skip(ftype)
14181 
      else:
14182 
        iprot.skip(ftype)
14183 
      iprot.readFieldEnd()
14184 
    iprot.readStructEnd()
14185 
 
14186 
  def write(self, oprot):
14187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14189 
      return
14190 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
14191 
    if self.success is not None:
14192 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14193 
      oprot.writeBool(self.success)
14194 
      oprot.writeFieldEnd()
14195 
    if self.ex is not None:
14196 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14197 
      self.ex.write(oprot)
14198 
      oprot.writeFieldEnd()
14199 
    oprot.writeFieldStop()
14200 
    oprot.writeStructEnd()
14201 
 
14202 
  def validate(self):
14203 
    return
14204 
 
14205 
 
14206 
  def __repr__(self):
14207 
    L = ['%s=%r' % (key, value)
14208 
      for key, value in self.__dict__.iteritems()]
14209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14210 
 
14211 
  def __eq__(self, other):
14212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14213 
 
14214 
  def __ne__(self, other):
14215 
    return not (self == other)
14216 
 
4488 rajveer 14217 
class markOrderReturnRequestReceived_args:
14218 
  """
14219 
  Attributes:
14220 
   - orderId
14221 
  """
14222 
 
14223 
  thrift_spec = (
14224 
    None, # 0
14225 
    (1, TType.I64, 'orderId', None, None, ), # 1
14226 
  )
14227 
 
14228 
  def __init__(self, orderId=None,):
14229 
    self.orderId = orderId
14230 
 
14231 
  def read(self, iprot):
14232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14234 
      return
14235 
    iprot.readStructBegin()
14236 
    while True:
14237 
      (fname, ftype, fid) = iprot.readFieldBegin()
14238 
      if ftype == TType.STOP:
14239 
        break
14240 
      if fid == 1:
14241 
        if ftype == TType.I64:
14242 
          self.orderId = iprot.readI64();
14243 
        else:
14244 
          iprot.skip(ftype)
14245 
      else:
14246 
        iprot.skip(ftype)
14247 
      iprot.readFieldEnd()
14248 
    iprot.readStructEnd()
14249 
 
14250 
  def write(self, oprot):
14251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14253 
      return
14254 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
14255 
    if self.orderId is not None:
14256 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14257 
      oprot.writeI64(self.orderId)
14258 
      oprot.writeFieldEnd()
14259 
    oprot.writeFieldStop()
14260 
    oprot.writeStructEnd()
14261 
 
14262 
  def validate(self):
14263 
    return
14264 
 
14265 
 
14266 
  def __repr__(self):
14267 
    L = ['%s=%r' % (key, value)
14268 
      for key, value in self.__dict__.iteritems()]
14269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14270 
 
14271 
  def __eq__(self, other):
14272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14273 
 
14274 
  def __ne__(self, other):
14275 
    return not (self == other)
14276 
 
14277 
class markOrderReturnRequestReceived_result:
14278 
  """
14279 
  Attributes:
14280 
   - success
14281 
   - ex
14282 
  """
14283 
 
14284 
  thrift_spec = (
14285 
    (0, TType.BOOL, 'success', None, None, ), # 0
14286 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14287 
  )
14288 
 
14289 
  def __init__(self, success=None, ex=None,):
14290 
    self.success = success
14291 
    self.ex = ex
14292 
 
14293 
  def read(self, iprot):
14294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14296 
      return
14297 
    iprot.readStructBegin()
14298 
    while True:
14299 
      (fname, ftype, fid) = iprot.readFieldBegin()
14300 
      if ftype == TType.STOP:
14301 
        break
14302 
      if fid == 0:
14303 
        if ftype == TType.BOOL:
14304 
          self.success = iprot.readBool();
14305 
        else:
14306 
          iprot.skip(ftype)
14307 
      elif fid == 1:
14308 
        if ftype == TType.STRUCT:
14309 
          self.ex = TransactionServiceException()
14310 
          self.ex.read(iprot)
14311 
        else:
14312 
          iprot.skip(ftype)
14313 
      else:
14314 
        iprot.skip(ftype)
14315 
      iprot.readFieldEnd()
14316 
    iprot.readStructEnd()
14317 
 
14318 
  def write(self, oprot):
14319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14321 
      return
14322 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
14323 
    if self.success is not None:
14324 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14325 
      oprot.writeBool(self.success)
14326 
      oprot.writeFieldEnd()
14327 
    if self.ex is not None:
14328 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14329 
      self.ex.write(oprot)
14330 
      oprot.writeFieldEnd()
14331 
    oprot.writeFieldStop()
14332 
    oprot.writeStructEnd()
14333 
 
14334 
  def validate(self):
14335 
    return
14336 
 
14337 
 
14338 
  def __repr__(self):
14339 
    L = ['%s=%r' % (key, value)
14340 
      for key, value in self.__dict__.iteritems()]
14341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14342 
 
14343 
  def __eq__(self, other):
14344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14345 
 
14346 
  def __ne__(self, other):
14347 
    return not (self == other)
14348 
 
14349 
class markOrderReturnRequestAuthorized_args:
14350 
  """
14351 
  Attributes:
14352 
   - orderId
14353 
   - isAuthorized
14354 
  """
14355 
 
14356 
  thrift_spec = (
14357 
    None, # 0
14358 
    (1, TType.I64, 'orderId', None, None, ), # 1
14359 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
14360 
  )
14361 
 
14362 
  def __init__(self, orderId=None, isAuthorized=None,):
14363 
    self.orderId = orderId
14364 
    self.isAuthorized = isAuthorized
14365 
 
14366 
  def read(self, iprot):
14367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14369 
      return
14370 
    iprot.readStructBegin()
14371 
    while True:
14372 
      (fname, ftype, fid) = iprot.readFieldBegin()
14373 
      if ftype == TType.STOP:
14374 
        break
14375 
      if fid == 1:
14376 
        if ftype == TType.I64:
14377 
          self.orderId = iprot.readI64();
14378 
        else:
14379 
          iprot.skip(ftype)
14380 
      elif fid == 2:
14381 
        if ftype == TType.BOOL:
14382 
          self.isAuthorized = iprot.readBool();
14383 
        else:
14384 
          iprot.skip(ftype)
14385 
      else:
14386 
        iprot.skip(ftype)
14387 
      iprot.readFieldEnd()
14388 
    iprot.readStructEnd()
14389 
 
14390 
  def write(self, oprot):
14391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14393 
      return
14394 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
14395 
    if self.orderId is not None:
14396 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14397 
      oprot.writeI64(self.orderId)
14398 
      oprot.writeFieldEnd()
14399 
    if self.isAuthorized is not None:
14400 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
14401 
      oprot.writeBool(self.isAuthorized)
14402 
      oprot.writeFieldEnd()
14403 
    oprot.writeFieldStop()
14404 
    oprot.writeStructEnd()
14405 
 
14406 
  def validate(self):
14407 
    return
14408 
 
14409 
 
14410 
  def __repr__(self):
14411 
    L = ['%s=%r' % (key, value)
14412 
      for key, value in self.__dict__.iteritems()]
14413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14414 
 
14415 
  def __eq__(self, other):
14416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14417 
 
14418 
  def __ne__(self, other):
14419 
    return not (self == other)
14420 
 
14421 
class markOrderReturnRequestAuthorized_result:
14422 
  """
14423 
  Attributes:
14424 
   - success
14425 
   - ex
14426 
  """
14427 
 
14428 
  thrift_spec = (
14429 
    (0, TType.BOOL, 'success', None, None, ), # 0
14430 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14431 
  )
14432 
 
14433 
  def __init__(self, success=None, ex=None,):
14434 
    self.success = success
14435 
    self.ex = ex
14436 
 
14437 
  def read(self, iprot):
14438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14440 
      return
14441 
    iprot.readStructBegin()
14442 
    while True:
14443 
      (fname, ftype, fid) = iprot.readFieldBegin()
14444 
      if ftype == TType.STOP:
14445 
        break
14446 
      if fid == 0:
14447 
        if ftype == TType.BOOL:
14448 
          self.success = iprot.readBool();
14449 
        else:
14450 
          iprot.skip(ftype)
14451 
      elif fid == 1:
14452 
        if ftype == TType.STRUCT:
14453 
          self.ex = TransactionServiceException()
14454 
          self.ex.read(iprot)
14455 
        else:
14456 
          iprot.skip(ftype)
14457 
      else:
14458 
        iprot.skip(ftype)
14459 
      iprot.readFieldEnd()
14460 
    iprot.readStructEnd()
14461 
 
14462 
  def write(self, oprot):
14463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14465 
      return
14466 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
14467 
    if self.success is not None:
14468 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14469 
      oprot.writeBool(self.success)
14470 
      oprot.writeFieldEnd()
14471 
    if self.ex is not None:
14472 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14473 
      self.ex.write(oprot)
14474 
      oprot.writeFieldEnd()
14475 
    oprot.writeFieldStop()
14476 
    oprot.writeStructEnd()
14477 
 
14478 
  def validate(self):
14479 
    return
14480 
 
14481 
 
14482 
  def __repr__(self):
14483 
    L = ['%s=%r' % (key, value)
14484 
      for key, value in self.__dict__.iteritems()]
14485 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14486 
 
14487 
  def __eq__(self, other):
14488 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14489 
 
14490 
  def __ne__(self, other):
14491 
    return not (self == other)
14492 
 
2536 chandransh 14493 
class requestPickupNumber_args:
14494 
  """
14495 
  Attributes:
14496 
   - orderId
4579 rajveer 14497 
   - providerId
2536 chandransh 14498 
  """
14499 
 
14500 
  thrift_spec = (
14501 
    None, # 0
14502 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 14503 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 14504 
  )
14505 
 
4579 rajveer 14506 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 14507 
    self.orderId = orderId
4579 rajveer 14508 
    self.providerId = providerId
2536 chandransh 14509 
 
14510 
  def read(self, iprot):
14511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14513 
      return
14514 
    iprot.readStructBegin()
14515 
    while True:
14516 
      (fname, ftype, fid) = iprot.readFieldBegin()
14517 
      if ftype == TType.STOP:
14518 
        break
14519 
      if fid == 1:
14520 
        if ftype == TType.I64:
14521 
          self.orderId = iprot.readI64();
14522 
        else:
14523 
          iprot.skip(ftype)
4579 rajveer 14524 
      elif fid == 2:
14525 
        if ftype == TType.I64:
14526 
          self.providerId = iprot.readI64();
14527 
        else:
14528 
          iprot.skip(ftype)
2536 chandransh 14529 
      else:
14530 
        iprot.skip(ftype)
14531 
      iprot.readFieldEnd()
14532 
    iprot.readStructEnd()
14533 
 
14534 
  def write(self, oprot):
14535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14537 
      return
14538 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 14539 
    if self.orderId is not None:
2536 chandransh 14540 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14541 
      oprot.writeI64(self.orderId)
14542 
      oprot.writeFieldEnd()
4579 rajveer 14543 
    if self.providerId is not None:
14544 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
14545 
      oprot.writeI64(self.providerId)
14546 
      oprot.writeFieldEnd()
2536 chandransh 14547 
    oprot.writeFieldStop()
14548 
    oprot.writeStructEnd()
14549 
 
3431 rajveer 14550 
  def validate(self):
14551 
    return
14552 
 
14553 
 
2536 chandransh 14554 
  def __repr__(self):
14555 
    L = ['%s=%r' % (key, value)
14556 
      for key, value in self.__dict__.iteritems()]
14557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14558 
 
14559 
  def __eq__(self, other):
14560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14561 
 
14562 
  def __ne__(self, other):
14563 
    return not (self == other)
14564 
 
14565 
class requestPickupNumber_result:
14566 
  """
14567 
  Attributes:
14568 
   - success
14569 
   - ex
14570 
  """
14571 
 
14572 
  thrift_spec = (
14573 
    (0, TType.BOOL, 'success', None, None, ), # 0
14574 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14575 
  )
14576 
 
14577 
  def __init__(self, success=None, ex=None,):
14578 
    self.success = success
14579 
    self.ex = ex
14580 
 
14581 
  def read(self, iprot):
14582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14584 
      return
14585 
    iprot.readStructBegin()
14586 
    while True:
14587 
      (fname, ftype, fid) = iprot.readFieldBegin()
14588 
      if ftype == TType.STOP:
14589 
        break
14590 
      if fid == 0:
14591 
        if ftype == TType.BOOL:
14592 
          self.success = iprot.readBool();
14593 
        else:
14594 
          iprot.skip(ftype)
14595 
      elif fid == 1:
14596 
        if ftype == TType.STRUCT:
14597 
          self.ex = TransactionServiceException()
14598 
          self.ex.read(iprot)
14599 
        else:
14600 
          iprot.skip(ftype)
14601 
      else:
14602 
        iprot.skip(ftype)
14603 
      iprot.readFieldEnd()
14604 
    iprot.readStructEnd()
14605 
 
14606 
  def write(self, oprot):
14607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14609 
      return
14610 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 14611 
    if self.success is not None:
2536 chandransh 14612 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14613 
      oprot.writeBool(self.success)
14614 
      oprot.writeFieldEnd()
3431 rajveer 14615 
    if self.ex is not None:
2536 chandransh 14616 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14617 
      self.ex.write(oprot)
14618 
      oprot.writeFieldEnd()
14619 
    oprot.writeFieldStop()
14620 
    oprot.writeStructEnd()
14621 
 
3431 rajveer 14622 
  def validate(self):
14623 
    return
14624 
 
14625 
 
2536 chandransh 14626 
  def __repr__(self):
14627 
    L = ['%s=%r' % (key, value)
14628 
      for key, value in self.__dict__.iteritems()]
14629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14630 
 
14631 
  def __eq__(self, other):
14632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14633 
 
14634 
  def __ne__(self, other):
14635 
    return not (self == other)
14636 
 
14637 
class authorizePickup_args:
14638 
  """
14639 
  Attributes:
14640 
   - orderId
14641 
   - pickupNumber
4602 rajveer 14642 
   - providerId
2536 chandransh 14643 
  """
14644 
 
14645 
  thrift_spec = (
14646 
    None, # 0
14647 
    (1, TType.I64, 'orderId', None, None, ), # 1
14648 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 14649 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 14650 
  )
14651 
 
4602 rajveer 14652 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 14653 
    self.orderId = orderId
14654 
    self.pickupNumber = pickupNumber
4602 rajveer 14655 
    self.providerId = providerId
2536 chandransh 14656 
 
14657 
  def read(self, iprot):
14658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14660 
      return
14661 
    iprot.readStructBegin()
14662 
    while True:
14663 
      (fname, ftype, fid) = iprot.readFieldBegin()
14664 
      if ftype == TType.STOP:
14665 
        break
14666 
      if fid == 1:
14667 
        if ftype == TType.I64:
14668 
          self.orderId = iprot.readI64();
14669 
        else:
14670 
          iprot.skip(ftype)
14671 
      elif fid == 2:
14672 
        if ftype == TType.STRING:
14673 
          self.pickupNumber = iprot.readString();
14674 
        else:
14675 
          iprot.skip(ftype)
4602 rajveer 14676 
      elif fid == 3:
14677 
        if ftype == TType.I64:
14678 
          self.providerId = iprot.readI64();
14679 
        else:
14680 
          iprot.skip(ftype)
2536 chandransh 14681 
      else:
14682 
        iprot.skip(ftype)
14683 
      iprot.readFieldEnd()
14684 
    iprot.readStructEnd()
14685 
 
14686 
  def write(self, oprot):
14687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14689 
      return
14690 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 14691 
    if self.orderId is not None:
2536 chandransh 14692 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14693 
      oprot.writeI64(self.orderId)
14694 
      oprot.writeFieldEnd()
3431 rajveer 14695 
    if self.pickupNumber is not None:
2536 chandransh 14696 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
14697 
      oprot.writeString(self.pickupNumber)
14698 
      oprot.writeFieldEnd()
4602 rajveer 14699 
    if self.providerId is not None:
14700 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
14701 
      oprot.writeI64(self.providerId)
14702 
      oprot.writeFieldEnd()
2536 chandransh 14703 
    oprot.writeFieldStop()
14704 
    oprot.writeStructEnd()
14705 
 
3431 rajveer 14706 
  def validate(self):
14707 
    return
14708 
 
14709 
 
2536 chandransh 14710 
  def __repr__(self):
14711 
    L = ['%s=%r' % (key, value)
14712 
      for key, value in self.__dict__.iteritems()]
14713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14714 
 
14715 
  def __eq__(self, other):
14716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14717 
 
14718 
  def __ne__(self, other):
14719 
    return not (self == other)
14720 
 
14721 
class authorizePickup_result:
14722 
  """
14723 
  Attributes:
14724 
   - success
14725 
   - ex
14726 
  """
14727 
 
14728 
  thrift_spec = (
14729 
    (0, TType.BOOL, 'success', None, None, ), # 0
14730 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14731 
  )
14732 
 
14733 
  def __init__(self, success=None, ex=None,):
14734 
    self.success = success
14735 
    self.ex = ex
14736 
 
14737 
  def read(self, iprot):
14738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14740 
      return
14741 
    iprot.readStructBegin()
14742 
    while True:
14743 
      (fname, ftype, fid) = iprot.readFieldBegin()
14744 
      if ftype == TType.STOP:
14745 
        break
14746 
      if fid == 0:
14747 
        if ftype == TType.BOOL:
14748 
          self.success = iprot.readBool();
14749 
        else:
14750 
          iprot.skip(ftype)
14751 
      elif fid == 1:
14752 
        if ftype == TType.STRUCT:
14753 
          self.ex = TransactionServiceException()
14754 
          self.ex.read(iprot)
14755 
        else:
14756 
          iprot.skip(ftype)
14757 
      else:
14758 
        iprot.skip(ftype)
14759 
      iprot.readFieldEnd()
14760 
    iprot.readStructEnd()
14761 
 
14762 
  def write(self, oprot):
14763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14765 
      return
14766 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 14767 
    if self.success is not None:
2536 chandransh 14768 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14769 
      oprot.writeBool(self.success)
14770 
      oprot.writeFieldEnd()
3431 rajveer 14771 
    if self.ex is not None:
2536 chandransh 14772 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14773 
      self.ex.write(oprot)
14774 
      oprot.writeFieldEnd()
14775 
    oprot.writeFieldStop()
14776 
    oprot.writeStructEnd()
14777 
 
3431 rajveer 14778 
  def validate(self):
14779 
    return
14780 
 
14781 
 
2536 chandransh 14782 
  def __repr__(self):
14783 
    L = ['%s=%r' % (key, value)
14784 
      for key, value in self.__dict__.iteritems()]
14785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14786 
 
14787 
  def __eq__(self, other):
14788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14789 
 
14790 
  def __ne__(self, other):
14791 
    return not (self == other)
14792 
 
2764 chandransh 14793 
class markDoasAsPickedUp_args:
14794 
  """
14795 
  Attributes:
14796 
   - providerId
14797 
   - pickupDetails
14798 
  """
14799 
 
14800 
  thrift_spec = (
14801 
    None, # 0
14802 
    (1, TType.I64, 'providerId', None, None, ), # 1
14803 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
14804 
  )
14805 
 
14806 
  def __init__(self, providerId=None, pickupDetails=None,):
14807 
    self.providerId = providerId
14808 
    self.pickupDetails = pickupDetails
14809 
 
14810 
  def read(self, iprot):
14811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14813 
      return
14814 
    iprot.readStructBegin()
14815 
    while True:
14816 
      (fname, ftype, fid) = iprot.readFieldBegin()
14817 
      if ftype == TType.STOP:
14818 
        break
14819 
      if fid == 1:
14820 
        if ftype == TType.I64:
14821 
          self.providerId = iprot.readI64();
14822 
        else:
14823 
          iprot.skip(ftype)
14824 
      elif fid == 2:
14825 
        if ftype == TType.MAP:
14826 
          self.pickupDetails = {}
5031 varun.gupt 14827 
          (_ktype323, _vtype324, _size322 ) = iprot.readMapBegin()
14828 
          for _i326 in xrange(_size322):
14829 
            _key327 = iprot.readString();
14830 
            _val328 = iprot.readString();
14831 
            self.pickupDetails[_key327] = _val328
2764 chandransh 14832 
          iprot.readMapEnd()
14833 
        else:
14834 
          iprot.skip(ftype)
14835 
      else:
14836 
        iprot.skip(ftype)
14837 
      iprot.readFieldEnd()
14838 
    iprot.readStructEnd()
14839 
 
14840 
  def write(self, oprot):
14841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14843 
      return
14844 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 14845 
    if self.providerId is not None:
2764 chandransh 14846 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14847 
      oprot.writeI64(self.providerId)
14848 
      oprot.writeFieldEnd()
3431 rajveer 14849 
    if self.pickupDetails is not None:
2764 chandransh 14850 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14851 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 14852 
      for kiter329,viter330 in self.pickupDetails.items():
14853 
        oprot.writeString(kiter329)
14854 
        oprot.writeString(viter330)
2764 chandransh 14855 
      oprot.writeMapEnd()
14856 
      oprot.writeFieldEnd()
14857 
    oprot.writeFieldStop()
14858 
    oprot.writeStructEnd()
14859 
 
3431 rajveer 14860 
  def validate(self):
14861 
    return
14862 
 
14863 
 
2764 chandransh 14864 
  def __repr__(self):
14865 
    L = ['%s=%r' % (key, value)
14866 
      for key, value in self.__dict__.iteritems()]
14867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14868 
 
14869 
  def __eq__(self, other):
14870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14871 
 
14872 
  def __ne__(self, other):
14873 
    return not (self == other)
14874 
 
14875 
class markDoasAsPickedUp_result:
4910 phani.kuma 14876 
 
14877 
  thrift_spec = (
14878 
  )
14879 
 
14880 
  def read(self, iprot):
14881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14883 
      return
14884 
    iprot.readStructBegin()
14885 
    while True:
14886 
      (fname, ftype, fid) = iprot.readFieldBegin()
14887 
      if ftype == TType.STOP:
14888 
        break
14889 
      else:
14890 
        iprot.skip(ftype)
14891 
      iprot.readFieldEnd()
14892 
    iprot.readStructEnd()
14893 
 
14894 
  def write(self, oprot):
14895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14897 
      return
14898 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
14899 
    oprot.writeFieldStop()
14900 
    oprot.writeStructEnd()
14901 
 
14902 
  def validate(self):
14903 
    return
14904 
 
14905 
 
14906 
  def __repr__(self):
14907 
    L = ['%s=%r' % (key, value)
14908 
      for key, value in self.__dict__.iteritems()]
14909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14910 
 
14911 
  def __eq__(self, other):
14912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14913 
 
14914 
  def __ne__(self, other):
14915 
    return not (self == other)
14916 
 
14917 
class getDoasNotPickedUp_args:
2764 chandransh 14918 
  """
14919 
  Attributes:
4910 phani.kuma 14920 
   - providerId
14921 
  """
14922 
 
14923 
  thrift_spec = (
14924 
    None, # 0
14925 
    (1, TType.I64, 'providerId', None, None, ), # 1
14926 
  )
14927 
 
14928 
  def __init__(self, providerId=None,):
14929 
    self.providerId = providerId
14930 
 
14931 
  def read(self, iprot):
14932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14934 
      return
14935 
    iprot.readStructBegin()
14936 
    while True:
14937 
      (fname, ftype, fid) = iprot.readFieldBegin()
14938 
      if ftype == TType.STOP:
14939 
        break
14940 
      if fid == 1:
14941 
        if ftype == TType.I64:
14942 
          self.providerId = iprot.readI64();
14943 
        else:
14944 
          iprot.skip(ftype)
14945 
      else:
14946 
        iprot.skip(ftype)
14947 
      iprot.readFieldEnd()
14948 
    iprot.readStructEnd()
14949 
 
14950 
  def write(self, oprot):
14951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14953 
      return
14954 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
14955 
    if self.providerId is not None:
14956 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14957 
      oprot.writeI64(self.providerId)
14958 
      oprot.writeFieldEnd()
14959 
    oprot.writeFieldStop()
14960 
    oprot.writeStructEnd()
14961 
 
14962 
  def validate(self):
14963 
    return
14964 
 
14965 
 
14966 
  def __repr__(self):
14967 
    L = ['%s=%r' % (key, value)
14968 
      for key, value in self.__dict__.iteritems()]
14969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14970 
 
14971 
  def __eq__(self, other):
14972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14973 
 
14974 
  def __ne__(self, other):
14975 
    return not (self == other)
14976 
 
14977 
class getDoasNotPickedUp_result:
14978 
  """
14979 
  Attributes:
2764 chandransh 14980 
   - success
14981 
  """
14982 
 
14983 
  thrift_spec = (
14984 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14985 
  )
14986 
 
14987 
  def __init__(self, success=None,):
14988 
    self.success = success
14989 
 
14990 
  def read(self, iprot):
14991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14993 
      return
14994 
    iprot.readStructBegin()
14995 
    while True:
14996 
      (fname, ftype, fid) = iprot.readFieldBegin()
14997 
      if ftype == TType.STOP:
14998 
        break
14999 
      if fid == 0:
15000 
        if ftype == TType.LIST:
15001 
          self.success = []
5031 varun.gupt 15002 
          (_etype334, _size331) = iprot.readListBegin()
15003 
          for _i335 in xrange(_size331):
15004 
            _elem336 = Order()
15005 
            _elem336.read(iprot)
15006 
            self.success.append(_elem336)
2764 chandransh 15007 
          iprot.readListEnd()
15008 
        else:
15009 
          iprot.skip(ftype)
15010 
      else:
15011 
        iprot.skip(ftype)
15012 
      iprot.readFieldEnd()
15013 
    iprot.readStructEnd()
15014 
 
15015 
  def write(self, oprot):
15016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15018 
      return
4910 phani.kuma 15019 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 15020 
    if self.success is not None:
2764 chandransh 15021 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15022 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 15023 
      for iter337 in self.success:
15024 
        iter337.write(oprot)
2764 chandransh 15025 
      oprot.writeListEnd()
15026 
      oprot.writeFieldEnd()
15027 
    oprot.writeFieldStop()
15028 
    oprot.writeStructEnd()
15029 
 
3431 rajveer 15030 
  def validate(self):
15031 
    return
15032 
 
15033 
 
2764 chandransh 15034 
  def __repr__(self):
15035 
    L = ['%s=%r' % (key, value)
15036 
      for key, value in self.__dict__.iteritems()]
15037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15038 
 
15039 
  def __eq__(self, other):
15040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15041 
 
15042 
  def __ne__(self, other):
15043 
    return not (self == other)
15044 
 
4741 phani.kuma 15045 
class markReturnOrdersAsPickedUp_args:
15046 
  """
15047 
  Attributes:
15048 
   - providerId
15049 
   - pickupDetails
15050 
  """
15051 
 
15052 
  thrift_spec = (
15053 
    None, # 0
15054 
    (1, TType.I64, 'providerId', None, None, ), # 1
15055 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
15056 
  )
15057 
 
15058 
  def __init__(self, providerId=None, pickupDetails=None,):
15059 
    self.providerId = providerId
15060 
    self.pickupDetails = pickupDetails
15061 
 
15062 
  def read(self, iprot):
15063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15065 
      return
15066 
    iprot.readStructBegin()
15067 
    while True:
15068 
      (fname, ftype, fid) = iprot.readFieldBegin()
15069 
      if ftype == TType.STOP:
15070 
        break
15071 
      if fid == 1:
15072 
        if ftype == TType.I64:
15073 
          self.providerId = iprot.readI64();
15074 
        else:
15075 
          iprot.skip(ftype)
15076 
      elif fid == 2:
15077 
        if ftype == TType.MAP:
15078 
          self.pickupDetails = {}
5031 varun.gupt 15079 
          (_ktype339, _vtype340, _size338 ) = iprot.readMapBegin()
15080 
          for _i342 in xrange(_size338):
15081 
            _key343 = iprot.readString();
15082 
            _val344 = iprot.readString();
15083 
            self.pickupDetails[_key343] = _val344
4741 phani.kuma 15084 
          iprot.readMapEnd()
15085 
        else:
15086 
          iprot.skip(ftype)
15087 
      else:
15088 
        iprot.skip(ftype)
15089 
      iprot.readFieldEnd()
15090 
    iprot.readStructEnd()
15091 
 
15092 
  def write(self, oprot):
15093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15095 
      return
15096 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
15097 
    if self.providerId is not None:
15098 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15099 
      oprot.writeI64(self.providerId)
15100 
      oprot.writeFieldEnd()
15101 
    if self.pickupDetails is not None:
15102 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15103 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5031 varun.gupt 15104 
      for kiter345,viter346 in self.pickupDetails.items():
15105 
        oprot.writeString(kiter345)
15106 
        oprot.writeString(viter346)
4741 phani.kuma 15107 
      oprot.writeMapEnd()
15108 
      oprot.writeFieldEnd()
15109 
    oprot.writeFieldStop()
15110 
    oprot.writeStructEnd()
15111 
 
15112 
  def validate(self):
15113 
    return
15114 
 
15115 
 
15116 
  def __repr__(self):
15117 
    L = ['%s=%r' % (key, value)
15118 
      for key, value in self.__dict__.iteritems()]
15119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15120 
 
15121 
  def __eq__(self, other):
15122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15123 
 
15124 
  def __ne__(self, other):
15125 
    return not (self == other)
15126 
 
15127 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 15128 
 
15129 
  thrift_spec = (
15130 
  )
15131 
 
15132 
  def read(self, iprot):
15133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15135 
      return
15136 
    iprot.readStructBegin()
15137 
    while True:
15138 
      (fname, ftype, fid) = iprot.readFieldBegin()
15139 
      if ftype == TType.STOP:
15140 
        break
15141 
      else:
15142 
        iprot.skip(ftype)
15143 
      iprot.readFieldEnd()
15144 
    iprot.readStructEnd()
15145 
 
15146 
  def write(self, oprot):
15147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15149 
      return
15150 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
15151 
    oprot.writeFieldStop()
15152 
    oprot.writeStructEnd()
15153 
 
15154 
  def validate(self):
15155 
    return
15156 
 
15157 
 
15158 
  def __repr__(self):
15159 
    L = ['%s=%r' % (key, value)
15160 
      for key, value in self.__dict__.iteritems()]
15161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15162 
 
15163 
  def __eq__(self, other):
15164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15165 
 
15166 
  def __ne__(self, other):
15167 
    return not (self == other)
15168 
 
15169 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 15170 
  """
15171 
  Attributes:
4910 phani.kuma 15172 
   - providerId
15173 
  """
15174 
 
15175 
  thrift_spec = (
15176 
    None, # 0
15177 
    (1, TType.I64, 'providerId', None, None, ), # 1
15178 
  )
15179 
 
15180 
  def __init__(self, providerId=None,):
15181 
    self.providerId = providerId
15182 
 
15183 
  def read(self, iprot):
15184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15186 
      return
15187 
    iprot.readStructBegin()
15188 
    while True:
15189 
      (fname, ftype, fid) = iprot.readFieldBegin()
15190 
      if ftype == TType.STOP:
15191 
        break
15192 
      if fid == 1:
15193 
        if ftype == TType.I64:
15194 
          self.providerId = iprot.readI64();
15195 
        else:
15196 
          iprot.skip(ftype)
15197 
      else:
15198 
        iprot.skip(ftype)
15199 
      iprot.readFieldEnd()
15200 
    iprot.readStructEnd()
15201 
 
15202 
  def write(self, oprot):
15203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15205 
      return
15206 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
15207 
    if self.providerId is not None:
15208 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15209 
      oprot.writeI64(self.providerId)
15210 
      oprot.writeFieldEnd()
15211 
    oprot.writeFieldStop()
15212 
    oprot.writeStructEnd()
15213 
 
15214 
  def validate(self):
15215 
    return
15216 
 
15217 
 
15218 
  def __repr__(self):
15219 
    L = ['%s=%r' % (key, value)
15220 
      for key, value in self.__dict__.iteritems()]
15221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15222 
 
15223 
  def __eq__(self, other):
15224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15225 
 
15226 
  def __ne__(self, other):
15227 
    return not (self == other)
15228 
 
15229 
class getReturnOrdersNotPickedUp_result:
15230 
  """
15231 
  Attributes:
4741 phani.kuma 15232 
   - success
15233 
  """
15234 
 
15235 
  thrift_spec = (
15236 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15237 
  )
15238 
 
15239 
  def __init__(self, success=None,):
15240 
    self.success = success
15241 
 
15242 
  def read(self, iprot):
15243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15245 
      return
15246 
    iprot.readStructBegin()
15247 
    while True:
15248 
      (fname, ftype, fid) = iprot.readFieldBegin()
15249 
      if ftype == TType.STOP:
15250 
        break
15251 
      if fid == 0:
15252 
        if ftype == TType.LIST:
15253 
          self.success = []
5031 varun.gupt 15254 
          (_etype350, _size347) = iprot.readListBegin()
15255 
          for _i351 in xrange(_size347):
15256 
            _elem352 = Order()
15257 
            _elem352.read(iprot)
15258 
            self.success.append(_elem352)
4741 phani.kuma 15259 
          iprot.readListEnd()
15260 
        else:
15261 
          iprot.skip(ftype)
15262 
      else:
15263 
        iprot.skip(ftype)
15264 
      iprot.readFieldEnd()
15265 
    iprot.readStructEnd()
15266 
 
15267 
  def write(self, oprot):
15268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15270 
      return
4910 phani.kuma 15271 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 15272 
    if self.success is not None:
15273 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15274 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 15275 
      for iter353 in self.success:
15276 
        iter353.write(oprot)
4741 phani.kuma 15277 
      oprot.writeListEnd()
15278 
      oprot.writeFieldEnd()
15279 
    oprot.writeFieldStop()
15280 
    oprot.writeStructEnd()
15281 
 
15282 
  def validate(self):
15283 
    return
15284 
 
15285 
 
15286 
  def __repr__(self):
15287 
    L = ['%s=%r' % (key, value)
15288 
      for key, value in self.__dict__.iteritems()]
15289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15290 
 
15291 
  def __eq__(self, other):
15292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15293 
 
15294 
  def __ne__(self, other):
15295 
    return not (self == other)
15296 
 
2616 chandransh 15297 
class receiveReturn_args:
2591 chandransh 15298 
  """
15299 
  Attributes:
15300 
   - orderId
4479 rajveer 15301 
   - receiveCondition
2591 chandransh 15302 
  """
2536 chandransh 15303 
 
2591 chandransh 15304 
  thrift_spec = (
15305 
    None, # 0
15306 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 15307 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 15308 
  )
15309 
 
4479 rajveer 15310 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 15311 
    self.orderId = orderId
4479 rajveer 15312 
    self.receiveCondition = receiveCondition
2591 chandransh 15313 
 
15314 
  def read(self, iprot):
15315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15317 
      return
15318 
    iprot.readStructBegin()
15319 
    while True:
15320 
      (fname, ftype, fid) = iprot.readFieldBegin()
15321 
      if ftype == TType.STOP:
15322 
        break
15323 
      if fid == 1:
15324 
        if ftype == TType.I64:
15325 
          self.orderId = iprot.readI64();
15326 
        else:
15327 
          iprot.skip(ftype)
4479 rajveer 15328 
      elif fid == 2:
15329 
        if ftype == TType.I64:
15330 
          self.receiveCondition = iprot.readI64();
15331 
        else:
15332 
          iprot.skip(ftype)
2591 chandransh 15333 
      else:
15334 
        iprot.skip(ftype)
15335 
      iprot.readFieldEnd()
15336 
    iprot.readStructEnd()
15337 
 
15338 
  def write(self, oprot):
15339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15341 
      return
2616 chandransh 15342 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 15343 
    if self.orderId is not None:
2591 chandransh 15344 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15345 
      oprot.writeI64(self.orderId)
15346 
      oprot.writeFieldEnd()
4479 rajveer 15347 
    if self.receiveCondition is not None:
15348 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
15349 
      oprot.writeI64(self.receiveCondition)
15350 
      oprot.writeFieldEnd()
2591 chandransh 15351 
    oprot.writeFieldStop()
15352 
    oprot.writeStructEnd()
15353 
 
3431 rajveer 15354 
  def validate(self):
15355 
    return
15356 
 
15357 
 
2591 chandransh 15358 
  def __repr__(self):
15359 
    L = ['%s=%r' % (key, value)
15360 
      for key, value in self.__dict__.iteritems()]
15361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15362 
 
15363 
  def __eq__(self, other):
15364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15365 
 
15366 
  def __ne__(self, other):
15367 
    return not (self == other)
15368 
 
2616 chandransh 15369 
class receiveReturn_result:
2591 chandransh 15370 
  """
15371 
  Attributes:
15372 
   - success
15373 
   - ex
15374 
  """
15375 
 
15376 
  thrift_spec = (
15377 
    (0, TType.BOOL, 'success', None, None, ), # 0
15378 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15379 
  )
15380 
 
15381 
  def __init__(self, success=None, ex=None,):
15382 
    self.success = success
15383 
    self.ex = ex
15384 
 
15385 
  def read(self, iprot):
15386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15388 
      return
15389 
    iprot.readStructBegin()
15390 
    while True:
15391 
      (fname, ftype, fid) = iprot.readFieldBegin()
15392 
      if ftype == TType.STOP:
15393 
        break
15394 
      if fid == 0:
15395 
        if ftype == TType.BOOL:
15396 
          self.success = iprot.readBool();
15397 
        else:
15398 
          iprot.skip(ftype)
15399 
      elif fid == 1:
15400 
        if ftype == TType.STRUCT:
15401 
          self.ex = TransactionServiceException()
15402 
          self.ex.read(iprot)
15403 
        else:
15404 
          iprot.skip(ftype)
15405 
      else:
15406 
        iprot.skip(ftype)
15407 
      iprot.readFieldEnd()
15408 
    iprot.readStructEnd()
15409 
 
15410 
  def write(self, oprot):
15411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15413 
      return
2616 chandransh 15414 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 15415 
    if self.success is not None:
2591 chandransh 15416 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15417 
      oprot.writeBool(self.success)
15418 
      oprot.writeFieldEnd()
3431 rajveer 15419 
    if self.ex is not None:
2591 chandransh 15420 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15421 
      self.ex.write(oprot)
15422 
      oprot.writeFieldEnd()
15423 
    oprot.writeFieldStop()
15424 
    oprot.writeStructEnd()
15425 
 
3431 rajveer 15426 
  def validate(self):
15427 
    return
15428 
 
15429 
 
2591 chandransh 15430 
  def __repr__(self):
15431 
    L = ['%s=%r' % (key, value)
15432 
      for key, value in self.__dict__.iteritems()]
15433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15434 
 
15435 
  def __eq__(self, other):
15436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15437 
 
15438 
  def __ne__(self, other):
15439 
    return not (self == other)
15440 
 
15441 
class validateDoa_args:
15442 
  """
15443 
  Attributes:
15444 
   - orderId
15445 
   - isValid
15446 
  """
15447 
 
15448 
  thrift_spec = (
15449 
    None, # 0
15450 
    (1, TType.I64, 'orderId', None, None, ), # 1
15451 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
15452 
  )
15453 
 
15454 
  def __init__(self, orderId=None, isValid=None,):
15455 
    self.orderId = orderId
15456 
    self.isValid = isValid
15457 
 
15458 
  def read(self, iprot):
15459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15461 
      return
15462 
    iprot.readStructBegin()
15463 
    while True:
15464 
      (fname, ftype, fid) = iprot.readFieldBegin()
15465 
      if ftype == TType.STOP:
15466 
        break
15467 
      if fid == 1:
15468 
        if ftype == TType.I64:
15469 
          self.orderId = iprot.readI64();
15470 
        else:
15471 
          iprot.skip(ftype)
15472 
      elif fid == 2:
15473 
        if ftype == TType.BOOL:
15474 
          self.isValid = iprot.readBool();
15475 
        else:
15476 
          iprot.skip(ftype)
15477 
      else:
15478 
        iprot.skip(ftype)
15479 
      iprot.readFieldEnd()
15480 
    iprot.readStructEnd()
15481 
 
15482 
  def write(self, oprot):
15483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15485 
      return
15486 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 15487 
    if self.orderId is not None:
2591 chandransh 15488 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15489 
      oprot.writeI64(self.orderId)
15490 
      oprot.writeFieldEnd()
3431 rajveer 15491 
    if self.isValid is not None:
2591 chandransh 15492 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
15493 
      oprot.writeBool(self.isValid)
15494 
      oprot.writeFieldEnd()
15495 
    oprot.writeFieldStop()
15496 
    oprot.writeStructEnd()
15497 
 
3431 rajveer 15498 
  def validate(self):
15499 
    return
15500 
 
15501 
 
2591 chandransh 15502 
  def __repr__(self):
15503 
    L = ['%s=%r' % (key, value)
15504 
      for key, value in self.__dict__.iteritems()]
15505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15506 
 
15507 
  def __eq__(self, other):
15508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15509 
 
15510 
  def __ne__(self, other):
15511 
    return not (self == other)
15512 
 
15513 
class validateDoa_result:
15514 
  """
15515 
  Attributes:
15516 
   - success
15517 
   - ex
15518 
  """
15519 
 
15520 
  thrift_spec = (
15521 
    (0, TType.BOOL, 'success', None, None, ), # 0
15522 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15523 
  )
15524 
 
15525 
  def __init__(self, success=None, ex=None,):
15526 
    self.success = success
15527 
    self.ex = ex
15528 
 
15529 
  def read(self, iprot):
15530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15532 
      return
15533 
    iprot.readStructBegin()
15534 
    while True:
15535 
      (fname, ftype, fid) = iprot.readFieldBegin()
15536 
      if ftype == TType.STOP:
15537 
        break
15538 
      if fid == 0:
15539 
        if ftype == TType.BOOL:
15540 
          self.success = iprot.readBool();
15541 
        else:
15542 
          iprot.skip(ftype)
15543 
      elif fid == 1:
15544 
        if ftype == TType.STRUCT:
15545 
          self.ex = TransactionServiceException()
15546 
          self.ex.read(iprot)
15547 
        else:
15548 
          iprot.skip(ftype)
15549 
      else:
15550 
        iprot.skip(ftype)
15551 
      iprot.readFieldEnd()
15552 
    iprot.readStructEnd()
15553 
 
15554 
  def write(self, oprot):
15555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15557 
      return
15558 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 15559 
    if self.success is not None:
2591 chandransh 15560 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15561 
      oprot.writeBool(self.success)
15562 
      oprot.writeFieldEnd()
3431 rajveer 15563 
    if self.ex is not None:
2591 chandransh 15564 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15565 
      self.ex.write(oprot)
15566 
      oprot.writeFieldEnd()
15567 
    oprot.writeFieldStop()
15568 
    oprot.writeStructEnd()
15569 
 
3431 rajveer 15570 
  def validate(self):
15571 
    return
15572 
 
15573 
 
2591 chandransh 15574 
  def __repr__(self):
15575 
    L = ['%s=%r' % (key, value)
15576 
      for key, value in self.__dict__.iteritems()]
15577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15578 
 
15579 
  def __eq__(self, other):
15580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15581 
 
15582 
  def __ne__(self, other):
15583 
    return not (self == other)
15584 
 
4495 rajveer 15585 
class validateReturnProduct_args:
15586 
  """
15587 
  Attributes:
15588 
   - orderId
15589 
   - isUsable
15590 
  """
15591 
 
15592 
  thrift_spec = (
15593 
    None, # 0
15594 
    (1, TType.I64, 'orderId', None, None, ), # 1
15595 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
15596 
  )
15597 
 
15598 
  def __init__(self, orderId=None, isUsable=None,):
15599 
    self.orderId = orderId
15600 
    self.isUsable = isUsable
15601 
 
15602 
  def read(self, iprot):
15603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15605 
      return
15606 
    iprot.readStructBegin()
15607 
    while True:
15608 
      (fname, ftype, fid) = iprot.readFieldBegin()
15609 
      if ftype == TType.STOP:
15610 
        break
15611 
      if fid == 1:
15612 
        if ftype == TType.I64:
15613 
          self.orderId = iprot.readI64();
15614 
        else:
15615 
          iprot.skip(ftype)
15616 
      elif fid == 2:
15617 
        if ftype == TType.BOOL:
15618 
          self.isUsable = iprot.readBool();
15619 
        else:
15620 
          iprot.skip(ftype)
15621 
      else:
15622 
        iprot.skip(ftype)
15623 
      iprot.readFieldEnd()
15624 
    iprot.readStructEnd()
15625 
 
15626 
  def write(self, oprot):
15627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15629 
      return
15630 
    oprot.writeStructBegin('validateReturnProduct_args')
15631 
    if self.orderId is not None:
15632 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15633 
      oprot.writeI64(self.orderId)
15634 
      oprot.writeFieldEnd()
15635 
    if self.isUsable is not None:
15636 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
15637 
      oprot.writeBool(self.isUsable)
15638 
      oprot.writeFieldEnd()
15639 
    oprot.writeFieldStop()
15640 
    oprot.writeStructEnd()
15641 
 
15642 
  def validate(self):
15643 
    return
15644 
 
15645 
 
15646 
  def __repr__(self):
15647 
    L = ['%s=%r' % (key, value)
15648 
      for key, value in self.__dict__.iteritems()]
15649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15650 
 
15651 
  def __eq__(self, other):
15652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15653 
 
15654 
  def __ne__(self, other):
15655 
    return not (self == other)
15656 
 
15657 
class validateReturnProduct_result:
15658 
  """
15659 
  Attributes:
15660 
   - success
15661 
   - ex
15662 
  """
15663 
 
15664 
  thrift_spec = (
15665 
    (0, TType.BOOL, 'success', None, None, ), # 0
15666 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15667 
  )
15668 
 
15669 
  def __init__(self, success=None, ex=None,):
15670 
    self.success = success
15671 
    self.ex = ex
15672 
 
15673 
  def read(self, iprot):
15674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15676 
      return
15677 
    iprot.readStructBegin()
15678 
    while True:
15679 
      (fname, ftype, fid) = iprot.readFieldBegin()
15680 
      if ftype == TType.STOP:
15681 
        break
15682 
      if fid == 0:
15683 
        if ftype == TType.BOOL:
15684 
          self.success = iprot.readBool();
15685 
        else:
15686 
          iprot.skip(ftype)
15687 
      elif fid == 1:
15688 
        if ftype == TType.STRUCT:
15689 
          self.ex = TransactionServiceException()
15690 
          self.ex.read(iprot)
15691 
        else:
15692 
          iprot.skip(ftype)
15693 
      else:
15694 
        iprot.skip(ftype)
15695 
      iprot.readFieldEnd()
15696 
    iprot.readStructEnd()
15697 
 
15698 
  def write(self, oprot):
15699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15701 
      return
15702 
    oprot.writeStructBegin('validateReturnProduct_result')
15703 
    if self.success is not None:
15704 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15705 
      oprot.writeBool(self.success)
15706 
      oprot.writeFieldEnd()
15707 
    if self.ex is not None:
15708 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15709 
      self.ex.write(oprot)
15710 
      oprot.writeFieldEnd()
15711 
    oprot.writeFieldStop()
15712 
    oprot.writeStructEnd()
15713 
 
15714 
  def validate(self):
15715 
    return
15716 
 
15717 
 
15718 
  def __repr__(self):
15719 
    L = ['%s=%r' % (key, value)
15720 
      for key, value in self.__dict__.iteritems()]
15721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15722 
 
15723 
  def __eq__(self, other):
15724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15725 
 
15726 
  def __ne__(self, other):
15727 
    return not (self == other)
15728 
 
2616 chandransh 15729 
class reshipOrder_args:
15730 
  """
15731 
  Attributes:
15732 
   - orderId
15733 
  """
2591 chandransh 15734 
 
2616 chandransh 15735 
  thrift_spec = (
15736 
    None, # 0
15737 
    (1, TType.I64, 'orderId', None, None, ), # 1
15738 
  )
15739 
 
15740 
  def __init__(self, orderId=None,):
15741 
    self.orderId = orderId
15742 
 
15743 
  def read(self, iprot):
15744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15746 
      return
15747 
    iprot.readStructBegin()
15748 
    while True:
15749 
      (fname, ftype, fid) = iprot.readFieldBegin()
15750 
      if ftype == TType.STOP:
15751 
        break
15752 
      if fid == 1:
15753 
        if ftype == TType.I64:
15754 
          self.orderId = iprot.readI64();
15755 
        else:
15756 
          iprot.skip(ftype)
15757 
      else:
15758 
        iprot.skip(ftype)
15759 
      iprot.readFieldEnd()
15760 
    iprot.readStructEnd()
15761 
 
15762 
  def write(self, oprot):
15763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15765 
      return
15766 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 15767 
    if self.orderId is not None:
2616 chandransh 15768 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15769 
      oprot.writeI64(self.orderId)
15770 
      oprot.writeFieldEnd()
15771 
    oprot.writeFieldStop()
15772 
    oprot.writeStructEnd()
15773 
 
3431 rajveer 15774 
  def validate(self):
15775 
    return
15776 
 
15777 
 
2616 chandransh 15778 
  def __repr__(self):
15779 
    L = ['%s=%r' % (key, value)
15780 
      for key, value in self.__dict__.iteritems()]
15781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15782 
 
15783 
  def __eq__(self, other):
15784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15785 
 
15786 
  def __ne__(self, other):
15787 
    return not (self == other)
15788 
 
15789 
class reshipOrder_result:
15790 
  """
15791 
  Attributes:
15792 
   - success
15793 
   - ex
15794 
  """
15795 
 
15796 
  thrift_spec = (
15797 
    (0, TType.I64, 'success', None, None, ), # 0
15798 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15799 
  )
15800 
 
15801 
  def __init__(self, success=None, ex=None,):
15802 
    self.success = success
15803 
    self.ex = ex
15804 
 
15805 
  def read(self, iprot):
15806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15808 
      return
15809 
    iprot.readStructBegin()
15810 
    while True:
15811 
      (fname, ftype, fid) = iprot.readFieldBegin()
15812 
      if ftype == TType.STOP:
15813 
        break
15814 
      if fid == 0:
15815 
        if ftype == TType.I64:
15816 
          self.success = iprot.readI64();
15817 
        else:
15818 
          iprot.skip(ftype)
15819 
      elif fid == 1:
15820 
        if ftype == TType.STRUCT:
15821 
          self.ex = TransactionServiceException()
15822 
          self.ex.read(iprot)
15823 
        else:
15824 
          iprot.skip(ftype)
15825 
      else:
15826 
        iprot.skip(ftype)
15827 
      iprot.readFieldEnd()
15828 
    iprot.readStructEnd()
15829 
 
15830 
  def write(self, oprot):
15831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15833 
      return
15834 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 15835 
    if self.success is not None:
2616 chandransh 15836 
      oprot.writeFieldBegin('success', TType.I64, 0)
15837 
      oprot.writeI64(self.success)
15838 
      oprot.writeFieldEnd()
3431 rajveer 15839 
    if self.ex is not None:
2616 chandransh 15840 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15841 
      self.ex.write(oprot)
15842 
      oprot.writeFieldEnd()
15843 
    oprot.writeFieldStop()
15844 
    oprot.writeStructEnd()
15845 
 
3431 rajveer 15846 
  def validate(self):
15847 
    return
15848 
 
15849 
 
2616 chandransh 15850 
  def __repr__(self):
15851 
    L = ['%s=%r' % (key, value)
15852 
      for key, value in self.__dict__.iteritems()]
15853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15854 
 
15855 
  def __eq__(self, other):
15856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15857 
 
15858 
  def __ne__(self, other):
15859 
    return not (self == other)
15860 
 
15861 
class refundOrder_args:
15862 
  """
15863 
  Attributes:
15864 
   - orderId
3226 chandransh 15865 
   - refundedBy
15866 
   - reason
2616 chandransh 15867 
  """
15868 
 
15869 
  thrift_spec = (
15870 
    None, # 0
15871 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 15872 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
15873 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 15874 
  )
15875 
 
3226 chandransh 15876 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 15877 
    self.orderId = orderId
3226 chandransh 15878 
    self.refundedBy = refundedBy
15879 
    self.reason = reason
2616 chandransh 15880 
 
15881 
  def read(self, iprot):
15882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15884 
      return
15885 
    iprot.readStructBegin()
15886 
    while True:
15887 
      (fname, ftype, fid) = iprot.readFieldBegin()
15888 
      if ftype == TType.STOP:
15889 
        break
15890 
      if fid == 1:
15891 
        if ftype == TType.I64:
15892 
          self.orderId = iprot.readI64();
15893 
        else:
15894 
          iprot.skip(ftype)
3226 chandransh 15895 
      elif fid == 2:
15896 
        if ftype == TType.STRING:
15897 
          self.refundedBy = iprot.readString();
15898 
        else:
15899 
          iprot.skip(ftype)
15900 
      elif fid == 3:
15901 
        if ftype == TType.STRING:
15902 
          self.reason = iprot.readString();
15903 
        else:
15904 
          iprot.skip(ftype)
2616 chandransh 15905 
      else:
15906 
        iprot.skip(ftype)
15907 
      iprot.readFieldEnd()
15908 
    iprot.readStructEnd()
15909 
 
15910 
  def write(self, oprot):
15911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15913 
      return
15914 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 15915 
    if self.orderId is not None:
2616 chandransh 15916 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15917 
      oprot.writeI64(self.orderId)
15918 
      oprot.writeFieldEnd()
3431 rajveer 15919 
    if self.refundedBy is not None:
3226 chandransh 15920 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
15921 
      oprot.writeString(self.refundedBy)
15922 
      oprot.writeFieldEnd()
3431 rajveer 15923 
    if self.reason is not None:
3226 chandransh 15924 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
15925 
      oprot.writeString(self.reason)
15926 
      oprot.writeFieldEnd()
2616 chandransh 15927 
    oprot.writeFieldStop()
15928 
    oprot.writeStructEnd()
15929 
 
3431 rajveer 15930 
  def validate(self):
15931 
    return
15932 
 
15933 
 
2616 chandransh 15934 
  def __repr__(self):
15935 
    L = ['%s=%r' % (key, value)
15936 
      for key, value in self.__dict__.iteritems()]
15937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15938 
 
15939 
  def __eq__(self, other):
15940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15941 
 
15942 
  def __ne__(self, other):
15943 
    return not (self == other)
15944 
 
15945 
class refundOrder_result:
15946 
  """
15947 
  Attributes:
15948 
   - success
15949 
   - ex
15950 
  """
15951 
 
15952 
  thrift_spec = (
15953 
    (0, TType.BOOL, 'success', None, None, ), # 0
15954 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15955 
  )
15956 
 
15957 
  def __init__(self, success=None, ex=None,):
15958 
    self.success = success
15959 
    self.ex = ex
15960 
 
15961 
  def read(self, iprot):
15962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15964 
      return
15965 
    iprot.readStructBegin()
15966 
    while True:
15967 
      (fname, ftype, fid) = iprot.readFieldBegin()
15968 
      if ftype == TType.STOP:
15969 
        break
15970 
      if fid == 0:
15971 
        if ftype == TType.BOOL:
15972 
          self.success = iprot.readBool();
15973 
        else:
15974 
          iprot.skip(ftype)
15975 
      elif fid == 1:
15976 
        if ftype == TType.STRUCT:
15977 
          self.ex = TransactionServiceException()
15978 
          self.ex.read(iprot)
15979 
        else:
15980 
          iprot.skip(ftype)
15981 
      else:
15982 
        iprot.skip(ftype)
15983 
      iprot.readFieldEnd()
15984 
    iprot.readStructEnd()
15985 
 
15986 
  def write(self, oprot):
15987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15989 
      return
15990 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 15991 
    if self.success is not None:
2616 chandransh 15992 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15993 
      oprot.writeBool(self.success)
15994 
      oprot.writeFieldEnd()
3431 rajveer 15995 
    if self.ex is not None:
2616 chandransh 15996 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15997 
      self.ex.write(oprot)
15998 
      oprot.writeFieldEnd()
15999 
    oprot.writeFieldStop()
16000 
    oprot.writeStructEnd()
16001 
 
3431 rajveer 16002 
  def validate(self):
16003 
    return
16004 
 
16005 
 
2616 chandransh 16006 
  def __repr__(self):
16007 
    L = ['%s=%r' % (key, value)
16008 
      for key, value in self.__dict__.iteritems()]
16009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16010 
 
16011 
  def __eq__(self, other):
16012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16013 
 
16014 
  def __ne__(self, other):
16015 
    return not (self == other)
16016 
 
2690 chandransh 16017 
class getReturnOrders_args:
16018 
  """
16019 
  Attributes:
16020 
   - warehouseId
16021 
   - fromDate
16022 
   - toDate
16023 
  """
2616 chandransh 16024 
 
2690 chandransh 16025 
  thrift_spec = (
16026 
    None, # 0
16027 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
16028 
    (2, TType.I64, 'fromDate', None, None, ), # 2
16029 
    (3, TType.I64, 'toDate', None, None, ), # 3
16030 
  )
16031 
 
16032 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
16033 
    self.warehouseId = warehouseId
16034 
    self.fromDate = fromDate
16035 
    self.toDate = toDate
16036 
 
16037 
  def read(self, iprot):
16038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16040 
      return
16041 
    iprot.readStructBegin()
16042 
    while True:
16043 
      (fname, ftype, fid) = iprot.readFieldBegin()
16044 
      if ftype == TType.STOP:
16045 
        break
16046 
      if fid == 1:
16047 
        if ftype == TType.I64:
16048 
          self.warehouseId = iprot.readI64();
16049 
        else:
16050 
          iprot.skip(ftype)
16051 
      elif fid == 2:
16052 
        if ftype == TType.I64:
16053 
          self.fromDate = iprot.readI64();
16054 
        else:
16055 
          iprot.skip(ftype)
16056 
      elif fid == 3:
16057 
        if ftype == TType.I64:
16058 
          self.toDate = iprot.readI64();
16059 
        else:
16060 
          iprot.skip(ftype)
16061 
      else:
16062 
        iprot.skip(ftype)
16063 
      iprot.readFieldEnd()
16064 
    iprot.readStructEnd()
16065 
 
16066 
  def write(self, oprot):
16067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16069 
      return
16070 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 16071 
    if self.warehouseId is not None:
2690 chandransh 16072 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
16073 
      oprot.writeI64(self.warehouseId)
16074 
      oprot.writeFieldEnd()
3431 rajveer 16075 
    if self.fromDate is not None:
2690 chandransh 16076 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
16077 
      oprot.writeI64(self.fromDate)
16078 
      oprot.writeFieldEnd()
3431 rajveer 16079 
    if self.toDate is not None:
2690 chandransh 16080 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
16081 
      oprot.writeI64(self.toDate)
16082 
      oprot.writeFieldEnd()
16083 
    oprot.writeFieldStop()
16084 
    oprot.writeStructEnd()
16085 
 
3431 rajveer 16086 
  def validate(self):
16087 
    return
16088 
 
16089 
 
2690 chandransh 16090 
  def __repr__(self):
16091 
    L = ['%s=%r' % (key, value)
16092 
      for key, value in self.__dict__.iteritems()]
16093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16094 
 
16095 
  def __eq__(self, other):
16096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16097 
 
16098 
  def __ne__(self, other):
16099 
    return not (self == other)
16100 
 
16101 
class getReturnOrders_result:
16102 
  """
16103 
  Attributes:
16104 
   - success
16105 
  """
16106 
 
16107 
  thrift_spec = (
16108 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
16109 
  )
16110 
 
16111 
  def __init__(self, success=None,):
16112 
    self.success = success
16113 
 
16114 
  def read(self, iprot):
16115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16117 
      return
16118 
    iprot.readStructBegin()
16119 
    while True:
16120 
      (fname, ftype, fid) = iprot.readFieldBegin()
16121 
      if ftype == TType.STOP:
16122 
        break
16123 
      if fid == 0:
16124 
        if ftype == TType.LIST:
16125 
          self.success = []
5031 varun.gupt 16126 
          (_etype357, _size354) = iprot.readListBegin()
16127 
          for _i358 in xrange(_size354):
16128 
            _elem359 = ReturnOrder()
16129 
            _elem359.read(iprot)
16130 
            self.success.append(_elem359)
2690 chandransh 16131 
          iprot.readListEnd()
16132 
        else:
16133 
          iprot.skip(ftype)
16134 
      else:
16135 
        iprot.skip(ftype)
16136 
      iprot.readFieldEnd()
16137 
    iprot.readStructEnd()
16138 
 
16139 
  def write(self, oprot):
16140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16142 
      return
16143 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 16144 
    if self.success is not None:
2690 chandransh 16145 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16146 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 16147 
      for iter360 in self.success:
16148 
        iter360.write(oprot)
2690 chandransh 16149 
      oprot.writeListEnd()
16150 
      oprot.writeFieldEnd()
16151 
    oprot.writeFieldStop()
16152 
    oprot.writeStructEnd()
16153 
 
3431 rajveer 16154 
  def validate(self):
16155 
    return
16156 
 
16157 
 
2690 chandransh 16158 
  def __repr__(self):
16159 
    L = ['%s=%r' % (key, value)
16160 
      for key, value in self.__dict__.iteritems()]
16161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16162 
 
16163 
  def __eq__(self, other):
16164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16165 
 
16166 
  def __ne__(self, other):
16167 
    return not (self == other)
16168 
 
2700 chandransh 16169 
class getReturnOrder_args:
16170 
  """
16171 
  Attributes:
16172 
   - id
16173 
  """
16174 
 
16175 
  thrift_spec = (
16176 
    None, # 0
16177 
    (1, TType.I64, 'id', None, None, ), # 1
16178 
  )
16179 
 
16180 
  def __init__(self, id=None,):
16181 
    self.id = id
16182 
 
16183 
  def read(self, iprot):
16184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16186 
      return
16187 
    iprot.readStructBegin()
16188 
    while True:
16189 
      (fname, ftype, fid) = iprot.readFieldBegin()
16190 
      if ftype == TType.STOP:
16191 
        break
16192 
      if fid == 1:
16193 
        if ftype == TType.I64:
16194 
          self.id = iprot.readI64();
16195 
        else:
16196 
          iprot.skip(ftype)
16197 
      else:
16198 
        iprot.skip(ftype)
16199 
      iprot.readFieldEnd()
16200 
    iprot.readStructEnd()
16201 
 
16202 
  def write(self, oprot):
16203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16205 
      return
16206 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 16207 
    if self.id is not None:
2700 chandransh 16208 
      oprot.writeFieldBegin('id', TType.I64, 1)
16209 
      oprot.writeI64(self.id)
16210 
      oprot.writeFieldEnd()
16211 
    oprot.writeFieldStop()
16212 
    oprot.writeStructEnd()
16213 
 
3431 rajveer 16214 
  def validate(self):
16215 
    return
16216 
 
16217 
 
2700 chandransh 16218 
  def __repr__(self):
16219 
    L = ['%s=%r' % (key, value)
16220 
      for key, value in self.__dict__.iteritems()]
16221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16222 
 
16223 
  def __eq__(self, other):
16224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16225 
 
16226 
  def __ne__(self, other):
16227 
    return not (self == other)
16228 
 
16229 
class getReturnOrder_result:
16230 
  """
16231 
  Attributes:
16232 
   - success
16233 
   - ex
16234 
  """
16235 
 
16236 
  thrift_spec = (
16237 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
16238 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16239 
  )
16240 
 
16241 
  def __init__(self, success=None, ex=None,):
16242 
    self.success = success
16243 
    self.ex = ex
16244 
 
16245 
  def read(self, iprot):
16246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16248 
      return
16249 
    iprot.readStructBegin()
16250 
    while True:
16251 
      (fname, ftype, fid) = iprot.readFieldBegin()
16252 
      if ftype == TType.STOP:
16253 
        break
16254 
      if fid == 0:
16255 
        if ftype == TType.STRUCT:
16256 
          self.success = ReturnOrder()
16257 
          self.success.read(iprot)
16258 
        else:
16259 
          iprot.skip(ftype)
16260 
      elif fid == 1:
16261 
        if ftype == TType.STRUCT:
16262 
          self.ex = TransactionServiceException()
16263 
          self.ex.read(iprot)
16264 
        else:
16265 
          iprot.skip(ftype)
16266 
      else:
16267 
        iprot.skip(ftype)
16268 
      iprot.readFieldEnd()
16269 
    iprot.readStructEnd()
16270 
 
16271 
  def write(self, oprot):
16272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16274 
      return
16275 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 16276 
    if self.success is not None:
2700 chandransh 16277 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16278 
      self.success.write(oprot)
16279 
      oprot.writeFieldEnd()
3431 rajveer 16280 
    if self.ex is not None:
2700 chandransh 16281 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16282 
      self.ex.write(oprot)
16283 
      oprot.writeFieldEnd()
16284 
    oprot.writeFieldStop()
16285 
    oprot.writeStructEnd()
16286 
 
3431 rajveer 16287 
  def validate(self):
16288 
    return
16289 
 
16290 
 
2700 chandransh 16291 
  def __repr__(self):
16292 
    L = ['%s=%r' % (key, value)
16293 
      for key, value in self.__dict__.iteritems()]
16294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16295 
 
16296 
  def __eq__(self, other):
16297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16298 
 
16299 
  def __ne__(self, other):
16300 
    return not (self == other)
16301 
 
2690 chandransh 16302 
class processReturn_args:
16303 
  """
16304 
  Attributes:
16305 
   - returnOrderId
16306 
  """
16307 
 
16308 
  thrift_spec = (
16309 
    None, # 0
16310 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
16311 
  )
16312 
 
16313 
  def __init__(self, returnOrderId=None,):
16314 
    self.returnOrderId = returnOrderId
16315 
 
16316 
  def read(self, iprot):
16317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16319 
      return
16320 
    iprot.readStructBegin()
16321 
    while True:
16322 
      (fname, ftype, fid) = iprot.readFieldBegin()
16323 
      if ftype == TType.STOP:
16324 
        break
16325 
      if fid == 1:
16326 
        if ftype == TType.I64:
16327 
          self.returnOrderId = iprot.readI64();
16328 
        else:
16329 
          iprot.skip(ftype)
16330 
      else:
16331 
        iprot.skip(ftype)
16332 
      iprot.readFieldEnd()
16333 
    iprot.readStructEnd()
16334 
 
16335 
  def write(self, oprot):
16336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16338 
      return
16339 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 16340 
    if self.returnOrderId is not None:
2690 chandransh 16341 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
16342 
      oprot.writeI64(self.returnOrderId)
16343 
      oprot.writeFieldEnd()
16344 
    oprot.writeFieldStop()
16345 
    oprot.writeStructEnd()
16346 
 
3431 rajveer 16347 
  def validate(self):
16348 
    return
16349 
 
16350 
 
2690 chandransh 16351 
  def __repr__(self):
16352 
    L = ['%s=%r' % (key, value)
16353 
      for key, value in self.__dict__.iteritems()]
16354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16355 
 
16356 
  def __eq__(self, other):
16357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16358 
 
16359 
  def __ne__(self, other):
16360 
    return not (self == other)
16361 
 
16362 
class processReturn_result:
16363 
  """
16364 
  Attributes:
16365 
   - ex
16366 
  """
16367 
 
16368 
  thrift_spec = (
16369 
    None, # 0
16370 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16371 
  )
16372 
 
16373 
  def __init__(self, ex=None,):
16374 
    self.ex = ex
16375 
 
16376 
  def read(self, iprot):
16377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16379 
      return
16380 
    iprot.readStructBegin()
16381 
    while True:
16382 
      (fname, ftype, fid) = iprot.readFieldBegin()
16383 
      if ftype == TType.STOP:
16384 
        break
16385 
      if fid == 1:
16386 
        if ftype == TType.STRUCT:
16387 
          self.ex = TransactionServiceException()
16388 
          self.ex.read(iprot)
16389 
        else:
16390 
          iprot.skip(ftype)
16391 
      else:
16392 
        iprot.skip(ftype)
16393 
      iprot.readFieldEnd()
16394 
    iprot.readStructEnd()
16395 
 
16396 
  def write(self, oprot):
16397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16399 
      return
16400 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 16401 
    if self.ex is not None:
2690 chandransh 16402 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16403 
      self.ex.write(oprot)
16404 
      oprot.writeFieldEnd()
16405 
    oprot.writeFieldStop()
16406 
    oprot.writeStructEnd()
16407 
 
3431 rajveer 16408 
  def validate(self):
16409 
    return
16410 
 
16411 
 
2690 chandransh 16412 
  def __repr__(self):
16413 
    L = ['%s=%r' % (key, value)
16414 
      for key, value in self.__dict__.iteritems()]
16415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16416 
 
16417 
  def __eq__(self, other):
16418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16419 
 
16420 
  def __ne__(self, other):
16421 
    return not (self == other)
16422 
 
3451 chandransh 16423 
class updateWeight_args:
16424 
  """
16425 
  Attributes:
16426 
   - orderId
16427 
   - weight
16428 
  """
16429 
 
16430 
  thrift_spec = (
16431 
    None, # 0
16432 
    (1, TType.I64, 'orderId', None, None, ), # 1
16433 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
16434 
  )
16435 
 
16436 
  def __init__(self, orderId=None, weight=None,):
16437 
    self.orderId = orderId
16438 
    self.weight = weight
16439 
 
16440 
  def read(self, iprot):
16441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16443 
      return
16444 
    iprot.readStructBegin()
16445 
    while True:
16446 
      (fname, ftype, fid) = iprot.readFieldBegin()
16447 
      if ftype == TType.STOP:
16448 
        break
16449 
      if fid == 1:
16450 
        if ftype == TType.I64:
16451 
          self.orderId = iprot.readI64();
16452 
        else:
16453 
          iprot.skip(ftype)
16454 
      elif fid == 2:
16455 
        if ftype == TType.DOUBLE:
16456 
          self.weight = iprot.readDouble();
16457 
        else:
16458 
          iprot.skip(ftype)
16459 
      else:
16460 
        iprot.skip(ftype)
16461 
      iprot.readFieldEnd()
16462 
    iprot.readStructEnd()
16463 
 
16464 
  def write(self, oprot):
16465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16467 
      return
16468 
    oprot.writeStructBegin('updateWeight_args')
16469 
    if self.orderId is not None:
16470 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16471 
      oprot.writeI64(self.orderId)
16472 
      oprot.writeFieldEnd()
16473 
    if self.weight is not None:
16474 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
16475 
      oprot.writeDouble(self.weight)
16476 
      oprot.writeFieldEnd()
16477 
    oprot.writeFieldStop()
16478 
    oprot.writeStructEnd()
16479 
 
16480 
  def validate(self):
16481 
    return
16482 
 
16483 
 
16484 
  def __repr__(self):
16485 
    L = ['%s=%r' % (key, value)
16486 
      for key, value in self.__dict__.iteritems()]
16487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16488 
 
16489 
  def __eq__(self, other):
16490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16491 
 
16492 
  def __ne__(self, other):
16493 
    return not (self == other)
16494 
 
16495 
class updateWeight_result:
16496 
  """
16497 
  Attributes:
16498 
   - success
16499 
   - ex
16500 
  """
16501 
 
16502 
  thrift_spec = (
16503 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16504 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16505 
  )
16506 
 
16507 
  def __init__(self, success=None, ex=None,):
16508 
    self.success = success
16509 
    self.ex = ex
16510 
 
16511 
  def read(self, iprot):
16512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16514 
      return
16515 
    iprot.readStructBegin()
16516 
    while True:
16517 
      (fname, ftype, fid) = iprot.readFieldBegin()
16518 
      if ftype == TType.STOP:
16519 
        break
16520 
      if fid == 0:
16521 
        if ftype == TType.STRUCT:
16522 
          self.success = Order()
16523 
          self.success.read(iprot)
16524 
        else:
16525 
          iprot.skip(ftype)
16526 
      elif fid == 1:
16527 
        if ftype == TType.STRUCT:
16528 
          self.ex = TransactionServiceException()
16529 
          self.ex.read(iprot)
16530 
        else:
16531 
          iprot.skip(ftype)
16532 
      else:
16533 
        iprot.skip(ftype)
16534 
      iprot.readFieldEnd()
16535 
    iprot.readStructEnd()
16536 
 
16537 
  def write(self, oprot):
16538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16540 
      return
16541 
    oprot.writeStructBegin('updateWeight_result')
16542 
    if self.success is not None:
16543 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16544 
      self.success.write(oprot)
16545 
      oprot.writeFieldEnd()
16546 
    if self.ex is not None:
16547 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16548 
      self.ex.write(oprot)
16549 
      oprot.writeFieldEnd()
16550 
    oprot.writeFieldStop()
16551 
    oprot.writeStructEnd()
16552 
 
16553 
  def validate(self):
16554 
    return
16555 
 
16556 
 
16557 
  def __repr__(self):
16558 
    L = ['%s=%r' % (key, value)
16559 
      for key, value in self.__dict__.iteritems()]
16560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16561 
 
16562 
  def __eq__(self, other):
16563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16564 
 
16565 
  def __ne__(self, other):
16566 
    return not (self == other)
3469 chandransh 16567 
 
16568 
class changeItem_args:
16569 
  """
16570 
  Attributes:
16571 
   - orderId
16572 
   - itemId
16573 
  """
16574 
 
16575 
  thrift_spec = (
16576 
    None, # 0
16577 
    (1, TType.I64, 'orderId', None, None, ), # 1
16578 
    (2, TType.I64, 'itemId', None, None, ), # 2
16579 
  )
16580 
 
16581 
  def __init__(self, orderId=None, itemId=None,):
16582 
    self.orderId = orderId
16583 
    self.itemId = itemId
16584 
 
16585 
  def read(self, iprot):
16586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16588 
      return
16589 
    iprot.readStructBegin()
16590 
    while True:
16591 
      (fname, ftype, fid) = iprot.readFieldBegin()
16592 
      if ftype == TType.STOP:
16593 
        break
16594 
      if fid == 1:
16595 
        if ftype == TType.I64:
16596 
          self.orderId = iprot.readI64();
16597 
        else:
16598 
          iprot.skip(ftype)
16599 
      elif fid == 2:
16600 
        if ftype == TType.I64:
16601 
          self.itemId = iprot.readI64();
16602 
        else:
16603 
          iprot.skip(ftype)
16604 
      else:
16605 
        iprot.skip(ftype)
16606 
      iprot.readFieldEnd()
16607 
    iprot.readStructEnd()
16608 
 
16609 
  def write(self, oprot):
16610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16612 
      return
16613 
    oprot.writeStructBegin('changeItem_args')
16614 
    if self.orderId is not None:
16615 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16616 
      oprot.writeI64(self.orderId)
16617 
      oprot.writeFieldEnd()
16618 
    if self.itemId is not None:
16619 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
16620 
      oprot.writeI64(self.itemId)
16621 
      oprot.writeFieldEnd()
16622 
    oprot.writeFieldStop()
16623 
    oprot.writeStructEnd()
16624 
 
16625 
  def validate(self):
16626 
    return
16627 
 
16628 
 
16629 
  def __repr__(self):
16630 
    L = ['%s=%r' % (key, value)
16631 
      for key, value in self.__dict__.iteritems()]
16632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16633 
 
16634 
  def __eq__(self, other):
16635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16636 
 
16637 
  def __ne__(self, other):
16638 
    return not (self == other)
16639 
 
16640 
class changeItem_result:
16641 
  """
16642 
  Attributes:
16643 
   - success
16644 
   - ex
16645 
  """
16646 
 
16647 
  thrift_spec = (
16648 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16649 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16650 
  )
16651 
 
16652 
  def __init__(self, success=None, ex=None,):
16653 
    self.success = success
16654 
    self.ex = ex
16655 
 
16656 
  def read(self, iprot):
16657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16659 
      return
16660 
    iprot.readStructBegin()
16661 
    while True:
16662 
      (fname, ftype, fid) = iprot.readFieldBegin()
16663 
      if ftype == TType.STOP:
16664 
        break
16665 
      if fid == 0:
16666 
        if ftype == TType.STRUCT:
16667 
          self.success = Order()
16668 
          self.success.read(iprot)
16669 
        else:
16670 
          iprot.skip(ftype)
16671 
      elif fid == 1:
16672 
        if ftype == TType.STRUCT:
16673 
          self.ex = TransactionServiceException()
16674 
          self.ex.read(iprot)
16675 
        else:
16676 
          iprot.skip(ftype)
16677 
      else:
16678 
        iprot.skip(ftype)
16679 
      iprot.readFieldEnd()
16680 
    iprot.readStructEnd()
16681 
 
16682 
  def write(self, oprot):
16683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16685 
      return
16686 
    oprot.writeStructBegin('changeItem_result')
16687 
    if self.success is not None:
16688 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16689 
      self.success.write(oprot)
16690 
      oprot.writeFieldEnd()
16691 
    if self.ex is not None:
16692 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16693 
      self.ex.write(oprot)
16694 
      oprot.writeFieldEnd()
16695 
    oprot.writeFieldStop()
16696 
    oprot.writeStructEnd()
16697 
 
16698 
  def validate(self):
16699 
    return
16700 
 
16701 
 
16702 
  def __repr__(self):
16703 
    L = ['%s=%r' % (key, value)
16704 
      for key, value in self.__dict__.iteritems()]
16705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16706 
 
16707 
  def __eq__(self, other):
16708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16709 
 
16710 
  def __ne__(self, other):
16711 
    return not (self == other)
16712 
 
16713 
class shiftToWarehouse_args:
16714 
  """
16715 
  Attributes:
16716 
   - orderId
16717 
   - warehouseId
16718 
  """
16719 
 
16720 
  thrift_spec = (
16721 
    None, # 0
16722 
    (1, TType.I64, 'orderId', None, None, ), # 1
16723 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
16724 
  )
16725 
 
16726 
  def __init__(self, orderId=None, warehouseId=None,):
16727 
    self.orderId = orderId
16728 
    self.warehouseId = warehouseId
16729 
 
16730 
  def read(self, iprot):
16731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16733 
      return
16734 
    iprot.readStructBegin()
16735 
    while True:
16736 
      (fname, ftype, fid) = iprot.readFieldBegin()
16737 
      if ftype == TType.STOP:
16738 
        break
16739 
      if fid == 1:
16740 
        if ftype == TType.I64:
16741 
          self.orderId = iprot.readI64();
16742 
        else:
16743 
          iprot.skip(ftype)
16744 
      elif fid == 2:
16745 
        if ftype == TType.I64:
16746 
          self.warehouseId = iprot.readI64();
16747 
        else:
16748 
          iprot.skip(ftype)
16749 
      else:
16750 
        iprot.skip(ftype)
16751 
      iprot.readFieldEnd()
16752 
    iprot.readStructEnd()
16753 
 
16754 
  def write(self, oprot):
16755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16757 
      return
16758 
    oprot.writeStructBegin('shiftToWarehouse_args')
16759 
    if self.orderId is not None:
16760 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16761 
      oprot.writeI64(self.orderId)
16762 
      oprot.writeFieldEnd()
16763 
    if self.warehouseId is not None:
16764 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16765 
      oprot.writeI64(self.warehouseId)
16766 
      oprot.writeFieldEnd()
16767 
    oprot.writeFieldStop()
16768 
    oprot.writeStructEnd()
16769 
 
16770 
  def validate(self):
16771 
    return
16772 
 
16773 
 
16774 
  def __repr__(self):
16775 
    L = ['%s=%r' % (key, value)
16776 
      for key, value in self.__dict__.iteritems()]
16777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16778 
 
16779 
  def __eq__(self, other):
16780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16781 
 
16782 
  def __ne__(self, other):
16783 
    return not (self == other)
16784 
 
16785 
class shiftToWarehouse_result:
16786 
  """
16787 
  Attributes:
16788 
   - success
16789 
   - ex
16790 
  """
16791 
 
16792 
  thrift_spec = (
16793 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
16794 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16795 
  )
16796 
 
16797 
  def __init__(self, success=None, ex=None,):
16798 
    self.success = success
16799 
    self.ex = ex
16800 
 
16801 
  def read(self, iprot):
16802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16804 
      return
16805 
    iprot.readStructBegin()
16806 
    while True:
16807 
      (fname, ftype, fid) = iprot.readFieldBegin()
16808 
      if ftype == TType.STOP:
16809 
        break
16810 
      if fid == 0:
16811 
        if ftype == TType.STRUCT:
16812 
          self.success = Order()
16813 
          self.success.read(iprot)
16814 
        else:
16815 
          iprot.skip(ftype)
16816 
      elif fid == 1:
16817 
        if ftype == TType.STRUCT:
16818 
          self.ex = TransactionServiceException()
16819 
          self.ex.read(iprot)
16820 
        else:
16821 
          iprot.skip(ftype)
16822 
      else:
16823 
        iprot.skip(ftype)
16824 
      iprot.readFieldEnd()
16825 
    iprot.readStructEnd()
16826 
 
16827 
  def write(self, oprot):
16828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16830 
      return
16831 
    oprot.writeStructBegin('shiftToWarehouse_result')
16832 
    if self.success is not None:
16833 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16834 
      self.success.write(oprot)
16835 
      oprot.writeFieldEnd()
16836 
    if self.ex is not None:
16837 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16838 
      self.ex.write(oprot)
16839 
      oprot.writeFieldEnd()
16840 
    oprot.writeFieldStop()
16841 
    oprot.writeStructEnd()
16842 
 
16843 
  def validate(self):
16844 
    return
16845 
 
16846 
 
16847 
  def __repr__(self):
16848 
    L = ['%s=%r' % (key, value)
16849 
      for key, value in self.__dict__.iteritems()]
16850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16851 
 
16852 
  def __eq__(self, other):
16853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16854 
 
16855 
  def __ne__(self, other):
16856 
    return not (self == other)
3553 chandransh 16857 
 
16858 
class addDelayReason_args:
16859 
  """
16860 
  Attributes:
16861 
   - orderId
16862 
   - delayReason
3986 chandransh 16863 
   - furtherDelay
4647 rajveer 16864 
   - delayReasonText
3553 chandransh 16865 
  """
16866 
 
16867 
  thrift_spec = (
16868 
    None, # 0
16869 
    (1, TType.I64, 'orderId', None, None, ), # 1
16870 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 16871 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 16872 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 16873 
  )
16874 
 
4647 rajveer 16875 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 16876 
    self.orderId = orderId
16877 
    self.delayReason = delayReason
3986 chandransh 16878 
    self.furtherDelay = furtherDelay
4647 rajveer 16879 
    self.delayReasonText = delayReasonText
3553 chandransh 16880 
 
16881 
  def read(self, iprot):
16882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16884 
      return
16885 
    iprot.readStructBegin()
16886 
    while True:
16887 
      (fname, ftype, fid) = iprot.readFieldBegin()
16888 
      if ftype == TType.STOP:
16889 
        break
16890 
      if fid == 1:
16891 
        if ftype == TType.I64:
16892 
          self.orderId = iprot.readI64();
16893 
        else:
16894 
          iprot.skip(ftype)
16895 
      elif fid == 2:
16896 
        if ftype == TType.I32:
16897 
          self.delayReason = iprot.readI32();
16898 
        else:
16899 
          iprot.skip(ftype)
3986 chandransh 16900 
      elif fid == 3:
16901 
        if ftype == TType.I64:
16902 
          self.furtherDelay = iprot.readI64();
16903 
        else:
16904 
          iprot.skip(ftype)
4647 rajveer 16905 
      elif fid == 4:
16906 
        if ftype == TType.STRING:
16907 
          self.delayReasonText = iprot.readString();
16908 
        else:
16909 
          iprot.skip(ftype)
3553 chandransh 16910 
      else:
16911 
        iprot.skip(ftype)
16912 
      iprot.readFieldEnd()
16913 
    iprot.readStructEnd()
16914 
 
16915 
  def write(self, oprot):
16916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16918 
      return
16919 
    oprot.writeStructBegin('addDelayReason_args')
16920 
    if self.orderId is not None:
16921 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16922 
      oprot.writeI64(self.orderId)
16923 
      oprot.writeFieldEnd()
16924 
    if self.delayReason is not None:
16925 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
16926 
      oprot.writeI32(self.delayReason)
16927 
      oprot.writeFieldEnd()
3986 chandransh 16928 
    if self.furtherDelay is not None:
16929 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
16930 
      oprot.writeI64(self.furtherDelay)
16931 
      oprot.writeFieldEnd()
4647 rajveer 16932 
    if self.delayReasonText is not None:
16933 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
16934 
      oprot.writeString(self.delayReasonText)
16935 
      oprot.writeFieldEnd()
3553 chandransh 16936 
    oprot.writeFieldStop()
16937 
    oprot.writeStructEnd()
16938 
 
16939 
  def validate(self):
16940 
    return
16941 
 
16942 
 
16943 
  def __repr__(self):
16944 
    L = ['%s=%r' % (key, value)
16945 
      for key, value in self.__dict__.iteritems()]
16946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16947 
 
16948 
  def __eq__(self, other):
16949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16950 
 
16951 
  def __ne__(self, other):
16952 
    return not (self == other)
16953 
 
16954 
class addDelayReason_result:
16955 
  """
16956 
  Attributes:
16957 
   - success
16958 
   - ex
16959 
  """
16960 
 
16961 
  thrift_spec = (
16962 
    (0, TType.BOOL, 'success', None, None, ), # 0
16963 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16964 
  )
16965 
 
16966 
  def __init__(self, success=None, ex=None,):
16967 
    self.success = success
16968 
    self.ex = ex
16969 
 
16970 
  def read(self, iprot):
16971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16973 
      return
16974 
    iprot.readStructBegin()
16975 
    while True:
16976 
      (fname, ftype, fid) = iprot.readFieldBegin()
16977 
      if ftype == TType.STOP:
16978 
        break
16979 
      if fid == 0:
16980 
        if ftype == TType.BOOL:
16981 
          self.success = iprot.readBool();
16982 
        else:
16983 
          iprot.skip(ftype)
16984 
      elif fid == 1:
16985 
        if ftype == TType.STRUCT:
16986 
          self.ex = TransactionServiceException()
16987 
          self.ex.read(iprot)
16988 
        else:
16989 
          iprot.skip(ftype)
16990 
      else:
16991 
        iprot.skip(ftype)
16992 
      iprot.readFieldEnd()
16993 
    iprot.readStructEnd()
16994 
 
16995 
  def write(self, oprot):
16996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16998 
      return
16999 
    oprot.writeStructBegin('addDelayReason_result')
17000 
    if self.success is not None:
17001 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17002 
      oprot.writeBool(self.success)
17003 
      oprot.writeFieldEnd()
17004 
    if self.ex is not None:
17005 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17006 
      self.ex.write(oprot)
17007 
      oprot.writeFieldEnd()
17008 
    oprot.writeFieldStop()
17009 
    oprot.writeStructEnd()
17010 
 
17011 
  def validate(self):
17012 
    return
17013 
 
17014 
 
17015 
  def __repr__(self):
17016 
    L = ['%s=%r' % (key, value)
17017 
      for key, value in self.__dict__.iteritems()]
17018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17019 
 
17020 
  def __eq__(self, other):
17021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17022 
 
17023 
  def __ne__(self, other):
17024 
    return not (self == other)
3956 chandransh 17025 
 
17026 
class reconcileCodCollection_args:
17027 
  """
17028 
  Attributes:
17029 
   - collectedAmountMap
17030 
   - xferBy
17031 
   - xferTxnId
17032 
   - xferDate
17033 
  """
17034 
 
17035 
  thrift_spec = (
17036 
    None, # 0
17037 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
17038 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
17039 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
17040 
    (4, TType.I64, 'xferDate', None, None, ), # 4
17041 
  )
17042 
 
17043 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
17044 
    self.collectedAmountMap = collectedAmountMap
17045 
    self.xferBy = xferBy
17046 
    self.xferTxnId = xferTxnId
17047 
    self.xferDate = xferDate
17048 
 
17049 
  def read(self, iprot):
17050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17052 
      return
17053 
    iprot.readStructBegin()
17054 
    while True:
17055 
      (fname, ftype, fid) = iprot.readFieldBegin()
17056 
      if ftype == TType.STOP:
17057 
        break
17058 
      if fid == 1:
17059 
        if ftype == TType.MAP:
17060 
          self.collectedAmountMap = {}
5031 varun.gupt 17061 
          (_ktype362, _vtype363, _size361 ) = iprot.readMapBegin()
17062 
          for _i365 in xrange(_size361):
17063 
            _key366 = iprot.readString();
17064 
            _val367 = iprot.readDouble();
17065 
            self.collectedAmountMap[_key366] = _val367
3956 chandransh 17066 
          iprot.readMapEnd()
17067 
        else:
17068 
          iprot.skip(ftype)
17069 
      elif fid == 2:
17070 
        if ftype == TType.STRING:
17071 
          self.xferBy = iprot.readString();
17072 
        else:
17073 
          iprot.skip(ftype)
17074 
      elif fid == 3:
17075 
        if ftype == TType.STRING:
17076 
          self.xferTxnId = iprot.readString();
17077 
        else:
17078 
          iprot.skip(ftype)
17079 
      elif fid == 4:
17080 
        if ftype == TType.I64:
17081 
          self.xferDate = iprot.readI64();
17082 
        else:
17083 
          iprot.skip(ftype)
17084 
      else:
17085 
        iprot.skip(ftype)
17086 
      iprot.readFieldEnd()
17087 
    iprot.readStructEnd()
17088 
 
17089 
  def write(self, oprot):
17090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17092 
      return
17093 
    oprot.writeStructBegin('reconcileCodCollection_args')
17094 
    if self.collectedAmountMap is not None:
17095 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
17096 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
5031 varun.gupt 17097 
      for kiter368,viter369 in self.collectedAmountMap.items():
17098 
        oprot.writeString(kiter368)
17099 
        oprot.writeDouble(viter369)
3956 chandransh 17100 
      oprot.writeMapEnd()
17101 
      oprot.writeFieldEnd()
17102 
    if self.xferBy is not None:
17103 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
17104 
      oprot.writeString(self.xferBy)
17105 
      oprot.writeFieldEnd()
17106 
    if self.xferTxnId is not None:
17107 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
17108 
      oprot.writeString(self.xferTxnId)
17109 
      oprot.writeFieldEnd()
17110 
    if self.xferDate is not None:
17111 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
17112 
      oprot.writeI64(self.xferDate)
17113 
      oprot.writeFieldEnd()
17114 
    oprot.writeFieldStop()
17115 
    oprot.writeStructEnd()
17116 
 
17117 
  def validate(self):
17118 
    return
17119 
 
17120 
 
17121 
  def __repr__(self):
17122 
    L = ['%s=%r' % (key, value)
17123 
      for key, value in self.__dict__.iteritems()]
17124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17125 
 
17126 
  def __eq__(self, other):
17127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17128 
 
17129 
  def __ne__(self, other):
17130 
    return not (self == other)
17131 
 
17132 
class reconcileCodCollection_result:
17133 
  """
17134 
  Attributes:
17135 
   - success
17136 
   - ex
17137 
  """
17138 
 
17139 
  thrift_spec = (
17140 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
17141 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17142 
  )
17143 
 
17144 
  def __init__(self, success=None, ex=None,):
17145 
    self.success = success
17146 
    self.ex = ex
17147 
 
17148 
  def read(self, iprot):
17149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17151 
      return
17152 
    iprot.readStructBegin()
17153 
    while True:
17154 
      (fname, ftype, fid) = iprot.readFieldBegin()
17155 
      if ftype == TType.STOP:
17156 
        break
17157 
      if fid == 0:
17158 
        if ftype == TType.MAP:
17159 
          self.success = {}
5031 varun.gupt 17160 
          (_ktype371, _vtype372, _size370 ) = iprot.readMapBegin()
17161 
          for _i374 in xrange(_size370):
17162 
            _key375 = iprot.readString();
17163 
            _val376 = iprot.readString();
17164 
            self.success[_key375] = _val376
3956 chandransh 17165 
          iprot.readMapEnd()
17166 
        else:
17167 
          iprot.skip(ftype)
17168 
      elif fid == 1:
17169 
        if ftype == TType.STRUCT:
17170 
          self.ex = TransactionServiceException()
17171 
          self.ex.read(iprot)
17172 
        else:
17173 
          iprot.skip(ftype)
17174 
      else:
17175 
        iprot.skip(ftype)
17176 
      iprot.readFieldEnd()
17177 
    iprot.readStructEnd()
17178 
 
17179 
  def write(self, oprot):
17180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17182 
      return
17183 
    oprot.writeStructBegin('reconcileCodCollection_result')
17184 
    if self.success is not None:
17185 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17186 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
5031 varun.gupt 17187 
      for kiter377,viter378 in self.success.items():
17188 
        oprot.writeString(kiter377)
17189 
        oprot.writeString(viter378)
3956 chandransh 17190 
      oprot.writeMapEnd()
17191 
      oprot.writeFieldEnd()
17192 
    if self.ex is not None:
17193 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17194 
      self.ex.write(oprot)
17195 
      oprot.writeFieldEnd()
17196 
    oprot.writeFieldStop()
17197 
    oprot.writeStructEnd()
17198 
 
17199 
  def validate(self):
17200 
    return
17201 
 
17202 
 
17203 
  def __repr__(self):
17204 
    L = ['%s=%r' % (key, value)
17205 
      for key, value in self.__dict__.iteritems()]
17206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17207 
 
17208 
  def __eq__(self, other):
17209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17210 
 
17211 
  def __ne__(self, other):
17212 
    return not (self == other)
4008 mandeep.dh 17213 
 
17214 
class getTransactionsRequiringExtraProcessing_args:
17215 
  """
17216 
  Attributes:
17217 
   - category
17218 
  """
17219 
 
17220 
  thrift_spec = (
17221 
    None, # 0
17222 
    (1, TType.I32, 'category', None, None, ), # 1
17223 
  )
17224 
 
17225 
  def __init__(self, category=None,):
17226 
    self.category = category
17227 
 
17228 
  def read(self, iprot):
17229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17231 
      return
17232 
    iprot.readStructBegin()
17233 
    while True:
17234 
      (fname, ftype, fid) = iprot.readFieldBegin()
17235 
      if ftype == TType.STOP:
17236 
        break
17237 
      if fid == 1:
17238 
        if ftype == TType.I32:
17239 
          self.category = iprot.readI32();
17240 
        else:
17241 
          iprot.skip(ftype)
17242 
      else:
17243 
        iprot.skip(ftype)
17244 
      iprot.readFieldEnd()
17245 
    iprot.readStructEnd()
17246 
 
17247 
  def write(self, oprot):
17248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17250 
      return
17251 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
17252 
    if self.category is not None:
17253 
      oprot.writeFieldBegin('category', TType.I32, 1)
17254 
      oprot.writeI32(self.category)
17255 
      oprot.writeFieldEnd()
17256 
    oprot.writeFieldStop()
17257 
    oprot.writeStructEnd()
17258 
 
17259 
  def validate(self):
17260 
    return
17261 
 
17262 
 
17263 
  def __repr__(self):
17264 
    L = ['%s=%r' % (key, value)
17265 
      for key, value in self.__dict__.iteritems()]
17266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17267 
 
17268 
  def __eq__(self, other):
17269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17270 
 
17271 
  def __ne__(self, other):
17272 
    return not (self == other)
17273 
 
17274 
class getTransactionsRequiringExtraProcessing_result:
17275 
  """
17276 
  Attributes:
17277 
   - success
17278 
  """
17279 
 
17280 
  thrift_spec = (
17281 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
17282 
  )
17283 
 
17284 
  def __init__(self, success=None,):
17285 
    self.success = success
17286 
 
17287 
  def read(self, iprot):
17288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17290 
      return
17291 
    iprot.readStructBegin()
17292 
    while True:
17293 
      (fname, ftype, fid) = iprot.readFieldBegin()
17294 
      if ftype == TType.STOP:
17295 
        break
17296 
      if fid == 0:
17297 
        if ftype == TType.LIST:
17298 
          self.success = []
5031 varun.gupt 17299 
          (_etype382, _size379) = iprot.readListBegin()
17300 
          for _i383 in xrange(_size379):
17301 
            _elem384 = iprot.readI64();
17302 
            self.success.append(_elem384)
4008 mandeep.dh 17303 
          iprot.readListEnd()
17304 
        else:
17305 
          iprot.skip(ftype)
17306 
      else:
17307 
        iprot.skip(ftype)
17308 
      iprot.readFieldEnd()
17309 
    iprot.readStructEnd()
17310 
 
17311 
  def write(self, oprot):
17312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17314 
      return
17315 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
17316 
    if self.success is not None:
17317 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17318 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 17319 
      for iter385 in self.success:
17320 
        oprot.writeI64(iter385)
4008 mandeep.dh 17321 
      oprot.writeListEnd()
17322 
      oprot.writeFieldEnd()
17323 
    oprot.writeFieldStop()
17324 
    oprot.writeStructEnd()
17325 
 
17326 
  def validate(self):
17327 
    return
17328 
 
17329 
 
17330 
  def __repr__(self):
17331 
    L = ['%s=%r' % (key, value)
17332 
      for key, value in self.__dict__.iteritems()]
17333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17334 
 
17335 
  def __eq__(self, other):
17336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17337 
 
17338 
  def __ne__(self, other):
17339 
    return not (self == other)
17340 
 
17341 
class markTransactionAsProcessed_args:
17342 
  """
17343 
  Attributes:
17344 
   - transactionId
17345 
   - category
17346 
  """
17347 
 
17348 
  thrift_spec = (
17349 
    None, # 0
17350 
    (1, TType.I64, 'transactionId', None, None, ), # 1
17351 
    (2, TType.I32, 'category', None, None, ), # 2
17352 
  )
17353 
 
17354 
  def __init__(self, transactionId=None, category=None,):
17355 
    self.transactionId = transactionId
17356 
    self.category = category
17357 
 
17358 
  def read(self, iprot):
17359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17361 
      return
17362 
    iprot.readStructBegin()
17363 
    while True:
17364 
      (fname, ftype, fid) = iprot.readFieldBegin()
17365 
      if ftype == TType.STOP:
17366 
        break
17367 
      if fid == 1:
17368 
        if ftype == TType.I64:
17369 
          self.transactionId = iprot.readI64();
17370 
        else:
17371 
          iprot.skip(ftype)
17372 
      elif fid == 2:
17373 
        if ftype == TType.I32:
17374 
          self.category = iprot.readI32();
17375 
        else:
17376 
          iprot.skip(ftype)
17377 
      else:
17378 
        iprot.skip(ftype)
17379 
      iprot.readFieldEnd()
17380 
    iprot.readStructEnd()
17381 
 
17382 
  def write(self, oprot):
17383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17385 
      return
17386 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
17387 
    if self.transactionId is not None:
17388 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
17389 
      oprot.writeI64(self.transactionId)
17390 
      oprot.writeFieldEnd()
17391 
    if self.category is not None:
17392 
      oprot.writeFieldBegin('category', TType.I32, 2)
17393 
      oprot.writeI32(self.category)
17394 
      oprot.writeFieldEnd()
17395 
    oprot.writeFieldStop()
17396 
    oprot.writeStructEnd()
17397 
 
17398 
  def validate(self):
17399 
    return
17400 
 
17401 
 
17402 
  def __repr__(self):
17403 
    L = ['%s=%r' % (key, value)
17404 
      for key, value in self.__dict__.iteritems()]
17405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17406 
 
17407 
  def __eq__(self, other):
17408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17409 
 
17410 
  def __ne__(self, other):
17411 
    return not (self == other)
17412 
 
17413 
class markTransactionAsProcessed_result:
17414 
 
17415 
  thrift_spec = (
17416 
  )
17417 
 
17418 
  def read(self, iprot):
17419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17421 
      return
17422 
    iprot.readStructBegin()
17423 
    while True:
17424 
      (fname, ftype, fid) = iprot.readFieldBegin()
17425 
      if ftype == TType.STOP:
17426 
        break
17427 
      else:
17428 
        iprot.skip(ftype)
17429 
      iprot.readFieldEnd()
17430 
    iprot.readStructEnd()
17431 
 
17432 
  def write(self, oprot):
17433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17435 
      return
17436 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
17437 
    oprot.writeFieldStop()
17438 
    oprot.writeStructEnd()
17439 
 
17440 
  def validate(self):
17441 
    return
17442 
 
17443 
 
17444 
  def __repr__(self):
17445 
    L = ['%s=%r' % (key, value)
17446 
      for key, value in self.__dict__.iteritems()]
17447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17448 
 
17449 
  def __eq__(self, other):
17450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17451 
 
17452 
  def __ne__(self, other):
17453 
    return not (self == other)
4018 chandransh 17454 
 
17455 
class getItemWiseRiskyOrdersCount_args:
17456 
 
17457 
  thrift_spec = (
17458 
  )
17459 
 
17460 
  def read(self, iprot):
17461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17463 
      return
17464 
    iprot.readStructBegin()
17465 
    while True:
17466 
      (fname, ftype, fid) = iprot.readFieldBegin()
17467 
      if ftype == TType.STOP:
17468 
        break
17469 
      else:
17470 
        iprot.skip(ftype)
17471 
      iprot.readFieldEnd()
17472 
    iprot.readStructEnd()
17473 
 
17474 
  def write(self, oprot):
17475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17477 
      return
17478 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
17479 
    oprot.writeFieldStop()
17480 
    oprot.writeStructEnd()
17481 
 
17482 
  def validate(self):
17483 
    return
17484 
 
17485 
 
17486 
  def __repr__(self):
17487 
    L = ['%s=%r' % (key, value)
17488 
      for key, value in self.__dict__.iteritems()]
17489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17490 
 
17491 
  def __eq__(self, other):
17492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17493 
 
17494 
  def __ne__(self, other):
17495 
    return not (self == other)
17496 
 
17497 
class getItemWiseRiskyOrdersCount_result:
17498 
  """
17499 
  Attributes:
17500 
   - success
17501 
  """
17502 
 
17503 
  thrift_spec = (
17504 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
17505 
  )
17506 
 
17507 
  def __init__(self, success=None,):
17508 
    self.success = success
17509 
 
17510 
  def read(self, iprot):
17511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17513 
      return
17514 
    iprot.readStructBegin()
17515 
    while True:
17516 
      (fname, ftype, fid) = iprot.readFieldBegin()
17517 
      if ftype == TType.STOP:
17518 
        break
17519 
      if fid == 0:
17520 
        if ftype == TType.MAP:
17521 
          self.success = {}
5031 varun.gupt 17522 
          (_ktype387, _vtype388, _size386 ) = iprot.readMapBegin()
17523 
          for _i390 in xrange(_size386):
17524 
            _key391 = iprot.readI64();
17525 
            _val392 = iprot.readI64();
17526 
            self.success[_key391] = _val392
4018 chandransh 17527 
          iprot.readMapEnd()
17528 
        else:
17529 
          iprot.skip(ftype)
17530 
      else:
17531 
        iprot.skip(ftype)
17532 
      iprot.readFieldEnd()
17533 
    iprot.readStructEnd()
17534 
 
17535 
  def write(self, oprot):
17536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17538 
      return
17539 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
17540 
    if self.success is not None:
17541 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17542 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5031 varun.gupt 17543 
      for kiter393,viter394 in self.success.items():
17544 
        oprot.writeI64(kiter393)
17545 
        oprot.writeI64(viter394)
4018 chandransh 17546 
      oprot.writeMapEnd()
17547 
      oprot.writeFieldEnd()
17548 
    oprot.writeFieldStop()
17549 
    oprot.writeStructEnd()
17550 
 
17551 
  def validate(self):
17552 
    return
17553 
 
17554 
 
17555 
  def __repr__(self):
17556 
    L = ['%s=%r' % (key, value)
17557 
      for key, value in self.__dict__.iteritems()]
17558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17559 
 
17560 
  def __eq__(self, other):
17561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17562 
 
17563 
  def __ne__(self, other):
17564 
    return not (self == other)
4247 rajveer 17565 
 
4295 varun.gupt 17566 
class getOrdersForItemIds_args:
17567 
  """
17568 
  Attributes:
17569 
   - itemIds
17570 
  """
17571 
 
17572 
  thrift_spec = (
17573 
    None, # 0
17574 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
17575 
  )
17576 
 
17577 
  def __init__(self, itemIds=None,):
17578 
    self.itemIds = itemIds
17579 
 
17580 
  def read(self, iprot):
17581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17583 
      return
17584 
    iprot.readStructBegin()
17585 
    while True:
17586 
      (fname, ftype, fid) = iprot.readFieldBegin()
17587 
      if ftype == TType.STOP:
17588 
        break
17589 
      if fid == 1:
17590 
        if ftype == TType.LIST:
17591 
          self.itemIds = []
5031 varun.gupt 17592 
          (_etype398, _size395) = iprot.readListBegin()
17593 
          for _i399 in xrange(_size395):
17594 
            _elem400 = iprot.readI64();
17595 
            self.itemIds.append(_elem400)
4295 varun.gupt 17596 
          iprot.readListEnd()
17597 
        else:
17598 
          iprot.skip(ftype)
17599 
      else:
17600 
        iprot.skip(ftype)
17601 
      iprot.readFieldEnd()
17602 
    iprot.readStructEnd()
17603 
 
17604 
  def write(self, oprot):
17605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17607 
      return
17608 
    oprot.writeStructBegin('getOrdersForItemIds_args')
17609 
    if self.itemIds is not None:
17610 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
17611 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5031 varun.gupt 17612 
      for iter401 in self.itemIds:
17613 
        oprot.writeI64(iter401)
4295 varun.gupt 17614 
      oprot.writeListEnd()
17615 
      oprot.writeFieldEnd()
17616 
    oprot.writeFieldStop()
17617 
    oprot.writeStructEnd()
17618 
 
17619 
  def validate(self):
17620 
    return
17621 
 
17622 
 
17623 
  def __repr__(self):
17624 
    L = ['%s=%r' % (key, value)
17625 
      for key, value in self.__dict__.iteritems()]
17626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17627 
 
17628 
  def __eq__(self, other):
17629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17630 
 
17631 
  def __ne__(self, other):
17632 
    return not (self == other)
17633 
 
17634 
class getOrdersForItemIds_result:
17635 
  """
17636 
  Attributes:
17637 
   - success
17638 
  """
17639 
 
17640 
  thrift_spec = (
17641 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17642 
  )
17643 
 
17644 
  def __init__(self, success=None,):
17645 
    self.success = success
17646 
 
17647 
  def read(self, iprot):
17648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17650 
      return
17651 
    iprot.readStructBegin()
17652 
    while True:
17653 
      (fname, ftype, fid) = iprot.readFieldBegin()
17654 
      if ftype == TType.STOP:
17655 
        break
17656 
      if fid == 0:
17657 
        if ftype == TType.LIST:
17658 
          self.success = []
5031 varun.gupt 17659 
          (_etype405, _size402) = iprot.readListBegin()
17660 
          for _i406 in xrange(_size402):
17661 
            _elem407 = Order()
17662 
            _elem407.read(iprot)
17663 
            self.success.append(_elem407)
4295 varun.gupt 17664 
          iprot.readListEnd()
17665 
        else:
17666 
          iprot.skip(ftype)
17667 
      else:
17668 
        iprot.skip(ftype)
17669 
      iprot.readFieldEnd()
17670 
    iprot.readStructEnd()
17671 
 
17672 
  def write(self, oprot):
17673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17675 
      return
17676 
    oprot.writeStructBegin('getOrdersForItemIds_result')
17677 
    if self.success is not None:
17678 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17679 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 17680 
      for iter408 in self.success:
17681 
        iter408.write(oprot)
4295 varun.gupt 17682 
      oprot.writeListEnd()
17683 
      oprot.writeFieldEnd()
17684 
    oprot.writeFieldStop()
17685 
    oprot.writeStructEnd()
17686 
 
17687 
  def validate(self):
17688 
    return
17689 
 
17690 
 
17691 
  def __repr__(self):
17692 
    L = ['%s=%r' % (key, value)
17693 
      for key, value in self.__dict__.iteritems()]
17694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17695 
 
17696 
  def __eq__(self, other):
17697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17698 
 
17699 
  def __ne__(self, other):
17700 
    return not (self == other)
17701 
 
4247 rajveer 17702 
class markOrderCancellationRequestReceived_args:
17703 
  """
17704 
  Attributes:
17705 
   - orderId
17706 
  """
17707 
 
17708 
  thrift_spec = (
17709 
    None, # 0
17710 
    (1, TType.I64, 'orderId', None, None, ), # 1
17711 
  )
17712 
 
17713 
  def __init__(self, orderId=None,):
17714 
    self.orderId = orderId
17715 
 
17716 
  def read(self, iprot):
17717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17719 
      return
17720 
    iprot.readStructBegin()
17721 
    while True:
17722 
      (fname, ftype, fid) = iprot.readFieldBegin()
17723 
      if ftype == TType.STOP:
17724 
        break
17725 
      if fid == 1:
17726 
        if ftype == TType.I64:
17727 
          self.orderId = iprot.readI64();
17728 
        else:
17729 
          iprot.skip(ftype)
17730 
      else:
17731 
        iprot.skip(ftype)
17732 
      iprot.readFieldEnd()
17733 
    iprot.readStructEnd()
17734 
 
17735 
  def write(self, oprot):
17736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17738 
      return
17739 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
17740 
    if self.orderId is not None:
17741 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17742 
      oprot.writeI64(self.orderId)
17743 
      oprot.writeFieldEnd()
17744 
    oprot.writeFieldStop()
17745 
    oprot.writeStructEnd()
17746 
 
17747 
  def validate(self):
17748 
    return
17749 
 
17750 
 
17751 
  def __repr__(self):
17752 
    L = ['%s=%r' % (key, value)
17753 
      for key, value in self.__dict__.iteritems()]
17754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17755 
 
17756 
  def __eq__(self, other):
17757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17758 
 
17759 
  def __ne__(self, other):
17760 
    return not (self == other)
17761 
 
17762 
class markOrderCancellationRequestReceived_result:
17763 
  """
17764 
  Attributes:
17765 
   - ex
17766 
  """
17767 
 
17768 
  thrift_spec = (
17769 
    None, # 0
17770 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17771 
  )
17772 
 
17773 
  def __init__(self, ex=None,):
17774 
    self.ex = ex
17775 
 
17776 
  def read(self, iprot):
17777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17779 
      return
17780 
    iprot.readStructBegin()
17781 
    while True:
17782 
      (fname, ftype, fid) = iprot.readFieldBegin()
17783 
      if ftype == TType.STOP:
17784 
        break
17785 
      if fid == 1:
17786 
        if ftype == TType.STRUCT:
17787 
          self.ex = TransactionServiceException()
17788 
          self.ex.read(iprot)
17789 
        else:
17790 
          iprot.skip(ftype)
17791 
      else:
17792 
        iprot.skip(ftype)
17793 
      iprot.readFieldEnd()
17794 
    iprot.readStructEnd()
17795 
 
17796 
  def write(self, oprot):
17797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17799 
      return
17800 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
17801 
    if self.ex is not None:
17802 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17803 
      self.ex.write(oprot)
17804 
      oprot.writeFieldEnd()
17805 
    oprot.writeFieldStop()
17806 
    oprot.writeStructEnd()
17807 
 
17808 
  def validate(self):
17809 
    return
17810 
 
17811 
 
17812 
  def __repr__(self):
17813 
    L = ['%s=%r' % (key, value)
17814 
      for key, value in self.__dict__.iteritems()]
17815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17816 
 
17817 
  def __eq__(self, other):
17818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17819 
 
17820 
  def __ne__(self, other):
17821 
    return not (self == other)
17822 
 
17823 
class markOrderCancellationRequestConfirmed_args:
17824 
  """
17825 
  Attributes:
17826 
   - orderId
17827 
  """
17828 
 
17829 
  thrift_spec = (
17830 
    None, # 0
17831 
    (1, TType.I64, 'orderId', None, None, ), # 1
17832 
  )
17833 
 
17834 
  def __init__(self, orderId=None,):
17835 
    self.orderId = orderId
17836 
 
17837 
  def read(self, iprot):
17838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17840 
      return
17841 
    iprot.readStructBegin()
17842 
    while True:
17843 
      (fname, ftype, fid) = iprot.readFieldBegin()
17844 
      if ftype == TType.STOP:
17845 
        break
17846 
      if fid == 1:
17847 
        if ftype == TType.I64:
17848 
          self.orderId = iprot.readI64();
17849 
        else:
17850 
          iprot.skip(ftype)
17851 
      else:
17852 
        iprot.skip(ftype)
17853 
      iprot.readFieldEnd()
17854 
    iprot.readStructEnd()
17855 
 
17856 
  def write(self, oprot):
17857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17859 
      return
17860 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
17861 
    if self.orderId is not None:
17862 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17863 
      oprot.writeI64(self.orderId)
17864 
      oprot.writeFieldEnd()
17865 
    oprot.writeFieldStop()
17866 
    oprot.writeStructEnd()
17867 
 
17868 
  def validate(self):
17869 
    return
17870 
 
17871 
 
17872 
  def __repr__(self):
17873 
    L = ['%s=%r' % (key, value)
17874 
      for key, value in self.__dict__.iteritems()]
17875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17876 
 
17877 
  def __eq__(self, other):
17878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17879 
 
17880 
  def __ne__(self, other):
17881 
    return not (self == other)
17882 
 
17883 
class markOrderCancellationRequestConfirmed_result:
17884 
  """
17885 
  Attributes:
17886 
   - ex
17887 
  """
17888 
 
17889 
  thrift_spec = (
17890 
    None, # 0
17891 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17892 
  )
17893 
 
17894 
  def __init__(self, ex=None,):
17895 
    self.ex = ex
17896 
 
17897 
  def read(self, iprot):
17898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17900 
      return
17901 
    iprot.readStructBegin()
17902 
    while True:
17903 
      (fname, ftype, fid) = iprot.readFieldBegin()
17904 
      if ftype == TType.STOP:
17905 
        break
17906 
      if fid == 1:
17907 
        if ftype == TType.STRUCT:
17908 
          self.ex = TransactionServiceException()
17909 
          self.ex.read(iprot)
17910 
        else:
17911 
          iprot.skip(ftype)
17912 
      else:
17913 
        iprot.skip(ftype)
17914 
      iprot.readFieldEnd()
17915 
    iprot.readStructEnd()
17916 
 
17917 
  def write(self, oprot):
17918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17920 
      return
17921 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
17922 
    if self.ex is not None:
17923 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17924 
      self.ex.write(oprot)
17925 
      oprot.writeFieldEnd()
17926 
    oprot.writeFieldStop()
17927 
    oprot.writeStructEnd()
17928 
 
17929 
  def validate(self):
17930 
    return
17931 
 
17932 
 
17933 
  def __repr__(self):
17934 
    L = ['%s=%r' % (key, value)
17935 
      for key, value in self.__dict__.iteritems()]
17936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17937 
 
17938 
  def __eq__(self, other):
17939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17940 
 
17941 
  def __ne__(self, other):
17942 
    return not (self == other)
17943 
 
17944 
class markOrderCancellationRequestDenied_args:
17945 
  """
17946 
  Attributes:
17947 
   - orderId
17948 
  """
17949 
 
17950 
  thrift_spec = (
17951 
    None, # 0
17952 
    (1, TType.I64, 'orderId', None, None, ), # 1
17953 
  )
17954 
 
17955 
  def __init__(self, orderId=None,):
17956 
    self.orderId = orderId
17957 
 
17958 
  def read(self, iprot):
17959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17961 
      return
17962 
    iprot.readStructBegin()
17963 
    while True:
17964 
      (fname, ftype, fid) = iprot.readFieldBegin()
17965 
      if ftype == TType.STOP:
17966 
        break
17967 
      if fid == 1:
17968 
        if ftype == TType.I64:
17969 
          self.orderId = iprot.readI64();
17970 
        else:
17971 
          iprot.skip(ftype)
17972 
      else:
17973 
        iprot.skip(ftype)
17974 
      iprot.readFieldEnd()
17975 
    iprot.readStructEnd()
17976 
 
17977 
  def write(self, oprot):
17978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17980 
      return
17981 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
17982 
    if self.orderId is not None:
17983 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17984 
      oprot.writeI64(self.orderId)
17985 
      oprot.writeFieldEnd()
17986 
    oprot.writeFieldStop()
17987 
    oprot.writeStructEnd()
17988 
 
17989 
  def validate(self):
17990 
    return
17991 
 
17992 
 
17993 
  def __repr__(self):
17994 
    L = ['%s=%r' % (key, value)
17995 
      for key, value in self.__dict__.iteritems()]
17996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17997 
 
17998 
  def __eq__(self, other):
17999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18000 
 
18001 
  def __ne__(self, other):
18002 
    return not (self == other)
18003 
 
18004 
class markOrderCancellationRequestDenied_result:
18005 
  """
18006 
  Attributes:
18007 
   - ex
18008 
  """
18009 
 
18010 
  thrift_spec = (
18011 
    None, # 0
18012 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18013 
  )
18014 
 
18015 
  def __init__(self, ex=None,):
18016 
    self.ex = ex
18017 
 
18018 
  def read(self, iprot):
18019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18021 
      return
18022 
    iprot.readStructBegin()
18023 
    while True:
18024 
      (fname, ftype, fid) = iprot.readFieldBegin()
18025 
      if ftype == TType.STOP:
18026 
        break
18027 
      if fid == 1:
18028 
        if ftype == TType.STRUCT:
18029 
          self.ex = TransactionServiceException()
18030 
          self.ex.read(iprot)
18031 
        else:
18032 
          iprot.skip(ftype)
18033 
      else:
18034 
        iprot.skip(ftype)
18035 
      iprot.readFieldEnd()
18036 
    iprot.readStructEnd()
18037 
 
18038 
  def write(self, oprot):
18039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18041 
      return
18042 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
18043 
    if self.ex is not None:
18044 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18045 
      self.ex.write(oprot)
18046 
      oprot.writeFieldEnd()
18047 
    oprot.writeFieldStop()
18048 
    oprot.writeStructEnd()
18049 
 
18050 
  def validate(self):
18051 
    return
18052 
 
18053 
 
18054 
  def __repr__(self):
18055 
    L = ['%s=%r' % (key, value)
18056 
      for key, value in self.__dict__.iteritems()]
18057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18058 
 
18059 
  def __eq__(self, other):
18060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18061 
 
18062 
  def __ne__(self, other):
18063 
    return not (self == other)
18064 
 
4258 rajveer 18065 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 18066 
  """
18067 
  Attributes:
4258 rajveer 18068 
   - transactionId
4247 rajveer 18069 
  """
18070 
 
18071 
  thrift_spec = (
18072 
    None, # 0
4258 rajveer 18073 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 18074 
  )
18075 
 
4258 rajveer 18076 
  def __init__(self, transactionId=None,):
18077 
    self.transactionId = transactionId
4247 rajveer 18078 
 
18079 
  def read(self, iprot):
18080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18082 
      return
18083 
    iprot.readStructBegin()
18084 
    while True:
18085 
      (fname, ftype, fid) = iprot.readFieldBegin()
18086 
      if ftype == TType.STOP:
18087 
        break
18088 
      if fid == 1:
18089 
        if ftype == TType.I64:
4258 rajveer 18090 
          self.transactionId = iprot.readI64();
4247 rajveer 18091 
        else:
18092 
          iprot.skip(ftype)
18093 
      else:
18094 
        iprot.skip(ftype)
18095 
      iprot.readFieldEnd()
18096 
    iprot.readStructEnd()
18097 
 
18098 
  def write(self, oprot):
18099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18101 
      return
4258 rajveer 18102 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
18103 
    if self.transactionId is not None:
18104 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18105 
      oprot.writeI64(self.transactionId)
4247 rajveer 18106 
      oprot.writeFieldEnd()
18107 
    oprot.writeFieldStop()
18108 
    oprot.writeStructEnd()
18109 
 
18110 
  def validate(self):
18111 
    return
18112 
 
18113 
 
18114 
  def __repr__(self):
18115 
    L = ['%s=%r' % (key, value)
18116 
      for key, value in self.__dict__.iteritems()]
18117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18118 
 
18119 
  def __eq__(self, other):
18120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18121 
 
18122 
  def __ne__(self, other):
18123 
    return not (self == other)
18124 
 
4258 rajveer 18125 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 18126 
  """
18127 
  Attributes:
18128 
   - ex
18129 
  """
18130 
 
18131 
  thrift_spec = (
18132 
    None, # 0
18133 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18134 
  )
18135 
 
18136 
  def __init__(self, ex=None,):
18137 
    self.ex = ex
18138 
 
18139 
  def read(self, iprot):
18140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18142 
      return
18143 
    iprot.readStructBegin()
18144 
    while True:
18145 
      (fname, ftype, fid) = iprot.readFieldBegin()
18146 
      if ftype == TType.STOP:
18147 
        break
18148 
      if fid == 1:
18149 
        if ftype == TType.STRUCT:
18150 
          self.ex = TransactionServiceException()
18151 
          self.ex.read(iprot)
18152 
        else:
18153 
          iprot.skip(ftype)
18154 
      else:
18155 
        iprot.skip(ftype)
18156 
      iprot.readFieldEnd()
18157 
    iprot.readStructEnd()
18158 
 
18159 
  def write(self, oprot):
18160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18162 
      return
4258 rajveer 18163 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 18164 
    if self.ex is not None:
18165 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18166 
      self.ex.write(oprot)
18167 
      oprot.writeFieldEnd()
18168 
    oprot.writeFieldStop()
18169 
    oprot.writeStructEnd()
18170 
 
18171 
  def validate(self):
18172 
    return
18173 
 
18174 
 
18175 
  def __repr__(self):
18176 
    L = ['%s=%r' % (key, value)
18177 
      for key, value in self.__dict__.iteritems()]
18178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18179 
 
18180 
  def __eq__(self, other):
18181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18182 
 
18183 
  def __ne__(self, other):
18184 
    return not (self == other)
4259 anupam.sin 18185 
 
18186 
class refundTransaction_args:
18187 
  """
18188 
  Attributes:
18189 
   - transactionId
18190 
   - refundedBy
18191 
   - reason
18192 
  """
18193 
 
18194 
  thrift_spec = (
18195 
    None, # 0
18196 
    (1, TType.I64, 'transactionId', None, None, ), # 1
18197 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18198 
    (3, TType.STRING, 'reason', None, None, ), # 3
18199 
  )
18200 
 
18201 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
18202 
    self.transactionId = transactionId
18203 
    self.refundedBy = refundedBy
18204 
    self.reason = reason
18205 
 
18206 
  def read(self, iprot):
18207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18209 
      return
18210 
    iprot.readStructBegin()
18211 
    while True:
18212 
      (fname, ftype, fid) = iprot.readFieldBegin()
18213 
      if ftype == TType.STOP:
18214 
        break
18215 
      if fid == 1:
18216 
        if ftype == TType.I64:
18217 
          self.transactionId = iprot.readI64();
18218 
        else:
18219 
          iprot.skip(ftype)
18220 
      elif fid == 2:
18221 
        if ftype == TType.STRING:
18222 
          self.refundedBy = iprot.readString();
18223 
        else:
18224 
          iprot.skip(ftype)
18225 
      elif fid == 3:
18226 
        if ftype == TType.STRING:
18227 
          self.reason = iprot.readString();
18228 
        else:
18229 
          iprot.skip(ftype)
18230 
      else:
18231 
        iprot.skip(ftype)
18232 
      iprot.readFieldEnd()
18233 
    iprot.readStructEnd()
18234 
 
18235 
  def write(self, oprot):
18236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18238 
      return
18239 
    oprot.writeStructBegin('refundTransaction_args')
18240 
    if self.transactionId is not None:
18241 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18242 
      oprot.writeI64(self.transactionId)
18243 
      oprot.writeFieldEnd()
18244 
    if self.refundedBy is not None:
18245 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18246 
      oprot.writeString(self.refundedBy)
18247 
      oprot.writeFieldEnd()
18248 
    if self.reason is not None:
18249 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18250 
      oprot.writeString(self.reason)
18251 
      oprot.writeFieldEnd()
18252 
    oprot.writeFieldStop()
18253 
    oprot.writeStructEnd()
18254 
 
18255 
  def validate(self):
18256 
    return
18257 
 
18258 
 
18259 
  def __repr__(self):
18260 
    L = ['%s=%r' % (key, value)
18261 
      for key, value in self.__dict__.iteritems()]
18262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18263 
 
18264 
  def __eq__(self, other):
18265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18266 
 
18267 
  def __ne__(self, other):
18268 
    return not (self == other)
18269 
 
18270 
class refundTransaction_result:
18271 
  """
18272 
  Attributes:
18273 
   - ex
18274 
  """
18275 
 
18276 
  thrift_spec = (
18277 
    None, # 0
18278 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18279 
  )
18280 
 
18281 
  def __init__(self, ex=None,):
18282 
    self.ex = ex
18283 
 
18284 
  def read(self, iprot):
18285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18287 
      return
18288 
    iprot.readStructBegin()
18289 
    while True:
18290 
      (fname, ftype, fid) = iprot.readFieldBegin()
18291 
      if ftype == TType.STOP:
18292 
        break
18293 
      if fid == 1:
18294 
        if ftype == TType.STRUCT:
18295 
          self.ex = TransactionServiceException()
18296 
          self.ex.read(iprot)
18297 
        else:
18298 
          iprot.skip(ftype)
18299 
      else:
18300 
        iprot.skip(ftype)
18301 
      iprot.readFieldEnd()
18302 
    iprot.readStructEnd()
18303 
 
18304 
  def write(self, oprot):
18305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18307 
      return
18308 
    oprot.writeStructBegin('refundTransaction_result')
18309 
    if self.ex is not None:
18310 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18311 
      self.ex.write(oprot)
18312 
      oprot.writeFieldEnd()
18313 
    oprot.writeFieldStop()
18314 
    oprot.writeStructEnd()
18315 
 
18316 
  def validate(self):
18317 
    return
18318 
 
18319 
 
18320 
  def __repr__(self):
18321 
    L = ['%s=%r' % (key, value)
18322 
      for key, value in self.__dict__.iteritems()]
18323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18324 
 
18325 
  def __eq__(self, other):
18326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18327 
 
18328 
  def __ne__(self, other):
18329 
    return not (self == other)
4285 rajveer 18330 
 
4324 mandeep.dh 18331 
class updateShipmentAddress_args:
18332 
  """
18333 
  Attributes:
18334 
   - orderId
18335 
   - addressId
18336 
  """
18337 
 
18338 
  thrift_spec = (
18339 
    None, # 0
18340 
    (1, TType.I64, 'orderId', None, None, ), # 1
18341 
    (2, TType.I64, 'addressId', None, None, ), # 2
18342 
  )
18343 
 
18344 
  def __init__(self, orderId=None, addressId=None,):
18345 
    self.orderId = orderId
18346 
    self.addressId = addressId
18347 
 
18348 
  def read(self, iprot):
18349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18351 
      return
18352 
    iprot.readStructBegin()
18353 
    while True:
18354 
      (fname, ftype, fid) = iprot.readFieldBegin()
18355 
      if ftype == TType.STOP:
18356 
        break
18357 
      if fid == 1:
18358 
        if ftype == TType.I64:
18359 
          self.orderId = iprot.readI64();
18360 
        else:
18361 
          iprot.skip(ftype)
18362 
      elif fid == 2:
18363 
        if ftype == TType.I64:
18364 
          self.addressId = iprot.readI64();
18365 
        else:
18366 
          iprot.skip(ftype)
18367 
      else:
18368 
        iprot.skip(ftype)
18369 
      iprot.readFieldEnd()
18370 
    iprot.readStructEnd()
18371 
 
18372 
  def write(self, oprot):
18373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18375 
      return
18376 
    oprot.writeStructBegin('updateShipmentAddress_args')
18377 
    if self.orderId is not None:
18378 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18379 
      oprot.writeI64(self.orderId)
18380 
      oprot.writeFieldEnd()
18381 
    if self.addressId is not None:
18382 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
18383 
      oprot.writeI64(self.addressId)
18384 
      oprot.writeFieldEnd()
18385 
    oprot.writeFieldStop()
18386 
    oprot.writeStructEnd()
18387 
 
18388 
  def validate(self):
18389 
    return
18390 
 
18391 
 
18392 
  def __repr__(self):
18393 
    L = ['%s=%r' % (key, value)
18394 
      for key, value in self.__dict__.iteritems()]
18395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18396 
 
18397 
  def __eq__(self, other):
18398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18399 
 
18400 
  def __ne__(self, other):
18401 
    return not (self == other)
18402 
 
18403 
class updateShipmentAddress_result:
18404 
  """
18405 
  Attributes:
18406 
   - ex
18407 
  """
18408 
 
18409 
  thrift_spec = (
18410 
    None, # 0
18411 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18412 
  )
18413 
 
18414 
  def __init__(self, ex=None,):
18415 
    self.ex = ex
18416 
 
18417 
  def read(self, iprot):
18418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18420 
      return
18421 
    iprot.readStructBegin()
18422 
    while True:
18423 
      (fname, ftype, fid) = iprot.readFieldBegin()
18424 
      if ftype == TType.STOP:
18425 
        break
18426 
      if fid == 1:
18427 
        if ftype == TType.STRUCT:
18428 
          self.ex = TransactionServiceException()
18429 
          self.ex.read(iprot)
18430 
        else:
18431 
          iprot.skip(ftype)
18432 
      else:
18433 
        iprot.skip(ftype)
18434 
      iprot.readFieldEnd()
18435 
    iprot.readStructEnd()
18436 
 
18437 
  def write(self, oprot):
18438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18440 
      return
18441 
    oprot.writeStructBegin('updateShipmentAddress_result')
18442 
    if self.ex is not None:
18443 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18444 
      self.ex.write(oprot)
18445 
      oprot.writeFieldEnd()
18446 
    oprot.writeFieldStop()
18447 
    oprot.writeStructEnd()
18448 
 
18449 
  def validate(self):
18450 
    return
18451 
 
18452 
 
18453 
  def __repr__(self):
18454 
    L = ['%s=%r' % (key, value)
18455 
      for key, value in self.__dict__.iteritems()]
18456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18457 
 
18458 
  def __eq__(self, other):
18459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18460 
 
18461 
  def __ne__(self, other):
18462 
    return not (self == other)
18463 
 
4285 rajveer 18464 
class acceptOrdersForItemId_args:
18465 
  """
18466 
  Attributes:
18467 
   - itemId
18468 
   - inventory
18469 
  """
18470 
 
18471 
  thrift_spec = (
18472 
    None, # 0
18473 
    (1, TType.I64, 'itemId', None, None, ), # 1
18474 
    (2, TType.I64, 'inventory', None, None, ), # 2
18475 
  )
18476 
 
18477 
  def __init__(self, itemId=None, inventory=None,):
18478 
    self.itemId = itemId
18479 
    self.inventory = inventory
18480 
 
18481 
  def read(self, iprot):
18482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18484 
      return
18485 
    iprot.readStructBegin()
18486 
    while True:
18487 
      (fname, ftype, fid) = iprot.readFieldBegin()
18488 
      if ftype == TType.STOP:
18489 
        break
18490 
      if fid == 1:
18491 
        if ftype == TType.I64:
18492 
          self.itemId = iprot.readI64();
18493 
        else:
18494 
          iprot.skip(ftype)
18495 
      elif fid == 2:
18496 
        if ftype == TType.I64:
18497 
          self.inventory = iprot.readI64();
18498 
        else:
18499 
          iprot.skip(ftype)
18500 
      else:
18501 
        iprot.skip(ftype)
18502 
      iprot.readFieldEnd()
18503 
    iprot.readStructEnd()
18504 
 
18505 
  def write(self, oprot):
18506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18508 
      return
18509 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
18510 
    if self.itemId is not None:
18511 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18512 
      oprot.writeI64(self.itemId)
18513 
      oprot.writeFieldEnd()
18514 
    if self.inventory is not None:
18515 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
18516 
      oprot.writeI64(self.inventory)
18517 
      oprot.writeFieldEnd()
18518 
    oprot.writeFieldStop()
18519 
    oprot.writeStructEnd()
18520 
 
18521 
  def validate(self):
18522 
    return
18523 
 
18524 
 
18525 
  def __repr__(self):
18526 
    L = ['%s=%r' % (key, value)
18527 
      for key, value in self.__dict__.iteritems()]
18528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18529 
 
18530 
  def __eq__(self, other):
18531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18532 
 
18533 
  def __ne__(self, other):
18534 
    return not (self == other)
18535 
 
18536 
class acceptOrdersForItemId_result:
18537 
  """
18538 
  Attributes:
18539 
   - success
18540 
   - ex
18541 
  """
18542 
 
18543 
  thrift_spec = (
18544 
    (0, TType.BOOL, 'success', None, None, ), # 0
18545 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18546 
  )
18547 
 
18548 
  def __init__(self, success=None, ex=None,):
18549 
    self.success = success
18550 
    self.ex = ex
18551 
 
18552 
  def read(self, iprot):
18553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18555 
      return
18556 
    iprot.readStructBegin()
18557 
    while True:
18558 
      (fname, ftype, fid) = iprot.readFieldBegin()
18559 
      if ftype == TType.STOP:
18560 
        break
18561 
      if fid == 0:
18562 
        if ftype == TType.BOOL:
18563 
          self.success = iprot.readBool();
18564 
        else:
18565 
          iprot.skip(ftype)
18566 
      elif fid == 1:
18567 
        if ftype == TType.STRUCT:
18568 
          self.ex = TransactionServiceException()
18569 
          self.ex.read(iprot)
18570 
        else:
18571 
          iprot.skip(ftype)
18572 
      else:
18573 
        iprot.skip(ftype)
18574 
      iprot.readFieldEnd()
18575 
    iprot.readStructEnd()
18576 
 
18577 
  def write(self, oprot):
18578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18580 
      return
18581 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
18582 
    if self.success is not None:
18583 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18584 
      oprot.writeBool(self.success)
18585 
      oprot.writeFieldEnd()
18586 
    if self.ex is not None:
18587 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18588 
      self.ex.write(oprot)
18589 
      oprot.writeFieldEnd()
18590 
    oprot.writeFieldStop()
18591 
    oprot.writeStructEnd()
18592 
 
18593 
  def validate(self):
18594 
    return
18595 
 
18596 
 
18597 
  def __repr__(self):
18598 
    L = ['%s=%r' % (key, value)
18599 
      for key, value in self.__dict__.iteritems()]
18600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18601 
 
18602 
  def __eq__(self, other):
18603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18604 
 
18605 
  def __ne__(self, other):
18606 
    return not (self == other)
4303 rajveer 18607 
 
18608 
class markOrdersAsPORaised_args:
18609 
  """
18610 
  Attributes:
18611 
   - vendorId
18612 
   - itemId
18613 
   - quantity
18614 
   - estimate
4369 rajveer 18615 
   - isReminder
4303 rajveer 18616 
  """
18617 
 
18618 
  thrift_spec = (
18619 
    None, # 0
18620 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18621 
    (2, TType.I64, 'itemId', None, None, ), # 2
18622 
    (3, TType.I64, 'quantity', None, None, ), # 3
18623 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18624 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18625 
  )
18626 
 
4369 rajveer 18627 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18628 
    self.vendorId = vendorId
18629 
    self.itemId = itemId
18630 
    self.quantity = quantity
18631 
    self.estimate = estimate
4369 rajveer 18632 
    self.isReminder = isReminder
4303 rajveer 18633 
 
18634 
  def read(self, iprot):
18635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18637 
      return
18638 
    iprot.readStructBegin()
18639 
    while True:
18640 
      (fname, ftype, fid) = iprot.readFieldBegin()
18641 
      if ftype == TType.STOP:
18642 
        break
18643 
      if fid == 1:
18644 
        if ftype == TType.I64:
18645 
          self.vendorId = iprot.readI64();
18646 
        else:
18647 
          iprot.skip(ftype)
18648 
      elif fid == 2:
18649 
        if ftype == TType.I64:
18650 
          self.itemId = iprot.readI64();
18651 
        else:
18652 
          iprot.skip(ftype)
18653 
      elif fid == 3:
18654 
        if ftype == TType.I64:
18655 
          self.quantity = iprot.readI64();
18656 
        else:
18657 
          iprot.skip(ftype)
18658 
      elif fid == 4:
18659 
        if ftype == TType.I64:
18660 
          self.estimate = iprot.readI64();
18661 
        else:
18662 
          iprot.skip(ftype)
4369 rajveer 18663 
      elif fid == 5:
18664 
        if ftype == TType.BOOL:
18665 
          self.isReminder = iprot.readBool();
18666 
        else:
18667 
          iprot.skip(ftype)
4303 rajveer 18668 
      else:
18669 
        iprot.skip(ftype)
18670 
      iprot.readFieldEnd()
18671 
    iprot.readStructEnd()
18672 
 
18673 
  def write(self, oprot):
18674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18676 
      return
18677 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
18678 
    if self.vendorId is not None:
18679 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18680 
      oprot.writeI64(self.vendorId)
18681 
      oprot.writeFieldEnd()
18682 
    if self.itemId is not None:
18683 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18684 
      oprot.writeI64(self.itemId)
18685 
      oprot.writeFieldEnd()
18686 
    if self.quantity is not None:
18687 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18688 
      oprot.writeI64(self.quantity)
18689 
      oprot.writeFieldEnd()
18690 
    if self.estimate is not None:
18691 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18692 
      oprot.writeI64(self.estimate)
18693 
      oprot.writeFieldEnd()
4369 rajveer 18694 
    if self.isReminder is not None:
18695 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18696 
      oprot.writeBool(self.isReminder)
18697 
      oprot.writeFieldEnd()
4303 rajveer 18698 
    oprot.writeFieldStop()
18699 
    oprot.writeStructEnd()
18700 
 
18701 
  def validate(self):
18702 
    return
18703 
 
18704 
 
18705 
  def __repr__(self):
18706 
    L = ['%s=%r' % (key, value)
18707 
      for key, value in self.__dict__.iteritems()]
18708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18709 
 
18710 
  def __eq__(self, other):
18711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18712 
 
18713 
  def __ne__(self, other):
18714 
    return not (self == other)
18715 
 
18716 
class markOrdersAsPORaised_result:
18717 
  """
18718 
  Attributes:
18719 
   - ex
18720 
  """
18721 
 
18722 
  thrift_spec = (
18723 
    None, # 0
18724 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18725 
  )
18726 
 
18727 
  def __init__(self, ex=None,):
18728 
    self.ex = ex
18729 
 
18730 
  def read(self, iprot):
18731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18733 
      return
18734 
    iprot.readStructBegin()
18735 
    while True:
18736 
      (fname, ftype, fid) = iprot.readFieldBegin()
18737 
      if ftype == TType.STOP:
18738 
        break
18739 
      if fid == 1:
18740 
        if ftype == TType.STRUCT:
18741 
          self.ex = TransactionServiceException()
18742 
          self.ex.read(iprot)
18743 
        else:
18744 
          iprot.skip(ftype)
18745 
      else:
18746 
        iprot.skip(ftype)
18747 
      iprot.readFieldEnd()
18748 
    iprot.readStructEnd()
18749 
 
18750 
  def write(self, oprot):
18751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18753 
      return
18754 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
18755 
    if self.ex is not None:
18756 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18757 
      self.ex.write(oprot)
18758 
      oprot.writeFieldEnd()
18759 
    oprot.writeFieldStop()
18760 
    oprot.writeStructEnd()
18761 
 
18762 
  def validate(self):
18763 
    return
18764 
 
18765 
 
18766 
  def __repr__(self):
18767 
    L = ['%s=%r' % (key, value)
18768 
      for key, value in self.__dict__.iteritems()]
18769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18770 
 
18771 
  def __eq__(self, other):
18772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18773 
 
18774 
  def __ne__(self, other):
18775 
    return not (self == other)
18776 
 
18777 
class markOrdersAsReversalInitiated_args:
18778 
  """
18779 
  Attributes:
18780 
   - vendorId
18781 
   - itemId
18782 
   - quantity
18783 
   - estimate
4369 rajveer 18784 
   - isReminder
4303 rajveer 18785 
  """
18786 
 
18787 
  thrift_spec = (
18788 
    None, # 0
18789 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18790 
    (2, TType.I64, 'itemId', None, None, ), # 2
18791 
    (3, TType.I64, 'quantity', None, None, ), # 3
18792 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18793 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18794 
  )
18795 
 
4369 rajveer 18796 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18797 
    self.vendorId = vendorId
18798 
    self.itemId = itemId
18799 
    self.quantity = quantity
18800 
    self.estimate = estimate
4369 rajveer 18801 
    self.isReminder = isReminder
4303 rajveer 18802 
 
18803 
  def read(self, iprot):
18804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18806 
      return
18807 
    iprot.readStructBegin()
18808 
    while True:
18809 
      (fname, ftype, fid) = iprot.readFieldBegin()
18810 
      if ftype == TType.STOP:
18811 
        break
18812 
      if fid == 1:
18813 
        if ftype == TType.I64:
18814 
          self.vendorId = iprot.readI64();
18815 
        else:
18816 
          iprot.skip(ftype)
18817 
      elif fid == 2:
18818 
        if ftype == TType.I64:
18819 
          self.itemId = iprot.readI64();
18820 
        else:
18821 
          iprot.skip(ftype)
18822 
      elif fid == 3:
18823 
        if ftype == TType.I64:
18824 
          self.quantity = iprot.readI64();
18825 
        else:
18826 
          iprot.skip(ftype)
18827 
      elif fid == 4:
18828 
        if ftype == TType.I64:
18829 
          self.estimate = iprot.readI64();
18830 
        else:
18831 
          iprot.skip(ftype)
4369 rajveer 18832 
      elif fid == 5:
18833 
        if ftype == TType.BOOL:
18834 
          self.isReminder = iprot.readBool();
18835 
        else:
18836 
          iprot.skip(ftype)
4303 rajveer 18837 
      else:
18838 
        iprot.skip(ftype)
18839 
      iprot.readFieldEnd()
18840 
    iprot.readStructEnd()
18841 
 
18842 
  def write(self, oprot):
18843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18845 
      return
18846 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
18847 
    if self.vendorId is not None:
18848 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
18849 
      oprot.writeI64(self.vendorId)
18850 
      oprot.writeFieldEnd()
18851 
    if self.itemId is not None:
18852 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18853 
      oprot.writeI64(self.itemId)
18854 
      oprot.writeFieldEnd()
18855 
    if self.quantity is not None:
18856 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
18857 
      oprot.writeI64(self.quantity)
18858 
      oprot.writeFieldEnd()
18859 
    if self.estimate is not None:
18860 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
18861 
      oprot.writeI64(self.estimate)
18862 
      oprot.writeFieldEnd()
4369 rajveer 18863 
    if self.isReminder is not None:
18864 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
18865 
      oprot.writeBool(self.isReminder)
18866 
      oprot.writeFieldEnd()
4303 rajveer 18867 
    oprot.writeFieldStop()
18868 
    oprot.writeStructEnd()
18869 
 
18870 
  def validate(self):
18871 
    return
18872 
 
18873 
 
18874 
  def __repr__(self):
18875 
    L = ['%s=%r' % (key, value)
18876 
      for key, value in self.__dict__.iteritems()]
18877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18878 
 
18879 
  def __eq__(self, other):
18880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18881 
 
18882 
  def __ne__(self, other):
18883 
    return not (self == other)
18884 
 
18885 
class markOrdersAsReversalInitiated_result:
18886 
  """
18887 
  Attributes:
18888 
   - ex
18889 
  """
18890 
 
18891 
  thrift_spec = (
18892 
    None, # 0
18893 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18894 
  )
18895 
 
18896 
  def __init__(self, ex=None,):
18897 
    self.ex = ex
18898 
 
18899 
  def read(self, iprot):
18900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18902 
      return
18903 
    iprot.readStructBegin()
18904 
    while True:
18905 
      (fname, ftype, fid) = iprot.readFieldBegin()
18906 
      if ftype == TType.STOP:
18907 
        break
18908 
      if fid == 1:
18909 
        if ftype == TType.STRUCT:
18910 
          self.ex = TransactionServiceException()
18911 
          self.ex.read(iprot)
18912 
        else:
18913 
          iprot.skip(ftype)
18914 
      else:
18915 
        iprot.skip(ftype)
18916 
      iprot.readFieldEnd()
18917 
    iprot.readStructEnd()
18918 
 
18919 
  def write(self, oprot):
18920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18922 
      return
18923 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
18924 
    if self.ex is not None:
18925 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18926 
      self.ex.write(oprot)
18927 
      oprot.writeFieldEnd()
18928 
    oprot.writeFieldStop()
18929 
    oprot.writeStructEnd()
18930 
 
18931 
  def validate(self):
18932 
    return
18933 
 
18934 
 
18935 
  def __repr__(self):
18936 
    L = ['%s=%r' % (key, value)
18937 
      for key, value in self.__dict__.iteritems()]
18938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18939 
 
18940 
  def __eq__(self, other):
18941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18942 
 
18943 
  def __ne__(self, other):
18944 
    return not (self == other)
18945 
 
18946 
class markOrdersAsNotAvailabke_args:
18947 
  """
18948 
  Attributes:
18949 
   - vendorId
18950 
   - itemId
18951 
   - quantity
18952 
   - estimate
4369 rajveer 18953 
   - isReminder
4303 rajveer 18954 
  """
18955 
 
18956 
  thrift_spec = (
18957 
    None, # 0
18958 
    (1, TType.I64, 'vendorId', None, None, ), # 1
18959 
    (2, TType.I64, 'itemId', None, None, ), # 2
18960 
    (3, TType.I64, 'quantity', None, None, ), # 3
18961 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 18962 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 18963 
  )
18964 
 
4369 rajveer 18965 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 18966 
    self.vendorId = vendorId
18967 
    self.itemId = itemId
18968 
    self.quantity = quantity
18969 
    self.estimate = estimate
4369 rajveer 18970 
    self.isReminder = isReminder
4303 rajveer 18971 
 
18972 
  def read(self, iprot):
18973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18975 
      return
18976 
    iprot.readStructBegin()
18977 
    while True:
18978 
      (fname, ftype, fid) = iprot.readFieldBegin()
18979 
      if ftype == TType.STOP:
18980 
        break
18981 
      if fid == 1:
18982 
        if ftype == TType.I64:
18983 
          self.vendorId = iprot.readI64();
18984 
        else:
18985 
          iprot.skip(ftype)
18986 
      elif fid == 2:
18987 
        if ftype == TType.I64:
18988 
          self.itemId = iprot.readI64();
18989 
        else:
18990 
          iprot.skip(ftype)
18991 
      elif fid == 3:
18992 
        if ftype == TType.I64:
18993 
          self.quantity = iprot.readI64();
18994 
        else:
18995 
          iprot.skip(ftype)
18996 
      elif fid == 4:
18997 
        if ftype == TType.I64:
18998 
          self.estimate = iprot.readI64();
18999 
        else:
19000 
          iprot.skip(ftype)
4369 rajveer 19001 
      elif fid == 5:
19002 
        if ftype == TType.BOOL:
19003 
          self.isReminder = iprot.readBool();
19004 
        else:
19005 
          iprot.skip(ftype)
4303 rajveer 19006 
      else:
19007 
        iprot.skip(ftype)
19008 
      iprot.readFieldEnd()
19009 
    iprot.readStructEnd()
19010 
 
19011 
  def write(self, oprot):
19012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19014 
      return
19015 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
19016 
    if self.vendorId is not None:
19017 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19018 
      oprot.writeI64(self.vendorId)
19019 
      oprot.writeFieldEnd()
19020 
    if self.itemId is not None:
19021 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19022 
      oprot.writeI64(self.itemId)
19023 
      oprot.writeFieldEnd()
19024 
    if self.quantity is not None:
19025 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
19026 
      oprot.writeI64(self.quantity)
19027 
      oprot.writeFieldEnd()
19028 
    if self.estimate is not None:
19029 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
19030 
      oprot.writeI64(self.estimate)
19031 
      oprot.writeFieldEnd()
4369 rajveer 19032 
    if self.isReminder is not None:
19033 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
19034 
      oprot.writeBool(self.isReminder)
19035 
      oprot.writeFieldEnd()
4303 rajveer 19036 
    oprot.writeFieldStop()
19037 
    oprot.writeStructEnd()
19038 
 
19039 
  def validate(self):
19040 
    return
19041 
 
19042 
 
19043 
  def __repr__(self):
19044 
    L = ['%s=%r' % (key, value)
19045 
      for key, value in self.__dict__.iteritems()]
19046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19047 
 
19048 
  def __eq__(self, other):
19049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19050 
 
19051 
  def __ne__(self, other):
19052 
    return not (self == other)
19053 
 
19054 
class markOrdersAsNotAvailabke_result:
19055 
  """
19056 
  Attributes:
19057 
   - ex
19058 
  """
19059 
 
19060 
  thrift_spec = (
19061 
    None, # 0
19062 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19063 
  )
19064 
 
19065 
  def __init__(self, ex=None,):
19066 
    self.ex = ex
19067 
 
19068 
  def read(self, iprot):
19069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19071 
      return
19072 
    iprot.readStructBegin()
19073 
    while True:
19074 
      (fname, ftype, fid) = iprot.readFieldBegin()
19075 
      if ftype == TType.STOP:
19076 
        break
19077 
      if fid == 1:
19078 
        if ftype == TType.STRUCT:
19079 
          self.ex = TransactionServiceException()
19080 
          self.ex.read(iprot)
19081 
        else:
19082 
          iprot.skip(ftype)
19083 
      else:
19084 
        iprot.skip(ftype)
19085 
      iprot.readFieldEnd()
19086 
    iprot.readStructEnd()
19087 
 
19088 
  def write(self, oprot):
19089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19091 
      return
19092 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
19093 
    if self.ex is not None:
19094 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19095 
      self.ex.write(oprot)
19096 
      oprot.writeFieldEnd()
19097 
    oprot.writeFieldStop()
19098 
    oprot.writeStructEnd()
19099 
 
19100 
  def validate(self):
19101 
    return
19102 
 
19103 
 
19104 
  def __repr__(self):
19105 
    L = ['%s=%r' % (key, value)
19106 
      for key, value in self.__dict__.iteritems()]
19107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19108 
 
19109 
  def __eq__(self, other):
19110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19111 
 
19112 
  def __ne__(self, other):
19113 
    return not (self == other)
4369 rajveer 19114 
 
19115 
class markOrdersAsTimeout_args:
19116 
  """
19117 
  Attributes:
19118 
   - vendorId
19119 
  """
19120 
 
19121 
  thrift_spec = (
19122 
    None, # 0
19123 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19124 
  )
19125 
 
19126 
  def __init__(self, vendorId=None,):
19127 
    self.vendorId = vendorId
19128 
 
19129 
  def read(self, iprot):
19130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19132 
      return
19133 
    iprot.readStructBegin()
19134 
    while True:
19135 
      (fname, ftype, fid) = iprot.readFieldBegin()
19136 
      if ftype == TType.STOP:
19137 
        break
19138 
      if fid == 1:
19139 
        if ftype == TType.I64:
19140 
          self.vendorId = iprot.readI64();
19141 
        else:
19142 
          iprot.skip(ftype)
19143 
      else:
19144 
        iprot.skip(ftype)
19145 
      iprot.readFieldEnd()
19146 
    iprot.readStructEnd()
19147 
 
19148 
  def write(self, oprot):
19149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19151 
      return
19152 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
19153 
    if self.vendorId is not None:
19154 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19155 
      oprot.writeI64(self.vendorId)
19156 
      oprot.writeFieldEnd()
19157 
    oprot.writeFieldStop()
19158 
    oprot.writeStructEnd()
19159 
 
19160 
  def validate(self):
19161 
    return
19162 
 
19163 
 
19164 
  def __repr__(self):
19165 
    L = ['%s=%r' % (key, value)
19166 
      for key, value in self.__dict__.iteritems()]
19167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19168 
 
19169 
  def __eq__(self, other):
19170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19171 
 
19172 
  def __ne__(self, other):
19173 
    return not (self == other)
19174 
 
19175 
class markOrdersAsTimeout_result:
19176 
  """
19177 
  Attributes:
19178 
   - success
19179 
   - ex
19180 
  """
19181 
 
19182 
  thrift_spec = (
19183 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
19184 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19185 
  )
19186 
 
19187 
  def __init__(self, success=None, ex=None,):
19188 
    self.success = success
19189 
    self.ex = ex
19190 
 
19191 
  def read(self, iprot):
19192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19194 
      return
19195 
    iprot.readStructBegin()
19196 
    while True:
19197 
      (fname, ftype, fid) = iprot.readFieldBegin()
19198 
      if ftype == TType.STOP:
19199 
        break
19200 
      if fid == 0:
19201 
        if ftype == TType.MAP:
19202 
          self.success = {}
5031 varun.gupt 19203 
          (_ktype410, _vtype411, _size409 ) = iprot.readMapBegin()
19204 
          for _i413 in xrange(_size409):
19205 
            _key414 = iprot.readI32();
19206 
            _val415 = TimeoutSummary()
19207 
            _val415.read(iprot)
19208 
            self.success[_key414] = _val415
4369 rajveer 19209 
          iprot.readMapEnd()
19210 
        else:
19211 
          iprot.skip(ftype)
19212 
      elif fid == 1:
19213 
        if ftype == TType.STRUCT:
19214 
          self.ex = TransactionServiceException()
19215 
          self.ex.read(iprot)
19216 
        else:
19217 
          iprot.skip(ftype)
19218 
      else:
19219 
        iprot.skip(ftype)
19220 
      iprot.readFieldEnd()
19221 
    iprot.readStructEnd()
19222 
 
19223 
  def write(self, oprot):
19224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19226 
      return
19227 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
19228 
    if self.success is not None:
19229 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19230 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
5031 varun.gupt 19231 
      for kiter416,viter417 in self.success.items():
19232 
        oprot.writeI32(kiter416)
19233 
        viter417.write(oprot)
4369 rajveer 19234 
      oprot.writeMapEnd()
19235 
      oprot.writeFieldEnd()
19236 
    if self.ex is not None:
19237 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19238 
      self.ex.write(oprot)
19239 
      oprot.writeFieldEnd()
19240 
    oprot.writeFieldStop()
19241 
    oprot.writeStructEnd()
19242 
 
19243 
  def validate(self):
19244 
    return
19245 
 
19246 
 
19247 
  def __repr__(self):
19248 
    L = ['%s=%r' % (key, value)
19249 
      for key, value in self.__dict__.iteritems()]
19250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19251 
 
19252 
  def __eq__(self, other):
19253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19254 
 
19255 
  def __ne__(self, other):
19256 
    return not (self == other)
4386 anupam.sin 19257 
 
4662 rajveer 19258 
class markOrderAsLostInTransit_args:
19259 
  """
19260 
  Attributes:
19261 
   - orderId
19262 
  """
19263 
 
19264 
  thrift_spec = (
19265 
    None, # 0
19266 
    (1, TType.I64, 'orderId', None, None, ), # 1
19267 
  )
19268 
 
19269 
  def __init__(self, orderId=None,):
19270 
    self.orderId = orderId
19271 
 
19272 
  def read(self, iprot):
19273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19275 
      return
19276 
    iprot.readStructBegin()
19277 
    while True:
19278 
      (fname, ftype, fid) = iprot.readFieldBegin()
19279 
      if ftype == TType.STOP:
19280 
        break
19281 
      if fid == 1:
19282 
        if ftype == TType.I64:
19283 
          self.orderId = iprot.readI64();
19284 
        else:
19285 
          iprot.skip(ftype)
19286 
      else:
19287 
        iprot.skip(ftype)
19288 
      iprot.readFieldEnd()
19289 
    iprot.readStructEnd()
19290 
 
19291 
  def write(self, oprot):
19292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19294 
      return
19295 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
19296 
    if self.orderId is not None:
19297 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19298 
      oprot.writeI64(self.orderId)
19299 
      oprot.writeFieldEnd()
19300 
    oprot.writeFieldStop()
19301 
    oprot.writeStructEnd()
19302 
 
19303 
  def validate(self):
19304 
    return
19305 
 
19306 
 
19307 
  def __repr__(self):
19308 
    L = ['%s=%r' % (key, value)
19309 
      for key, value in self.__dict__.iteritems()]
19310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19311 
 
19312 
  def __eq__(self, other):
19313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19314 
 
19315 
  def __ne__(self, other):
19316 
    return not (self == other)
19317 
 
19318 
class markOrderAsLostInTransit_result:
19319 
  """
19320 
  Attributes:
19321 
   - success
19322 
   - ex
19323 
  """
19324 
 
19325 
  thrift_spec = (
19326 
    (0, TType.BOOL, 'success', None, None, ), # 0
19327 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19328 
  )
19329 
 
19330 
  def __init__(self, success=None, ex=None,):
19331 
    self.success = success
19332 
    self.ex = ex
19333 
 
19334 
  def read(self, iprot):
19335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19337 
      return
19338 
    iprot.readStructBegin()
19339 
    while True:
19340 
      (fname, ftype, fid) = iprot.readFieldBegin()
19341 
      if ftype == TType.STOP:
19342 
        break
19343 
      if fid == 0:
19344 
        if ftype == TType.BOOL:
19345 
          self.success = iprot.readBool();
19346 
        else:
19347 
          iprot.skip(ftype)
19348 
      elif fid == 1:
19349 
        if ftype == TType.STRUCT:
19350 
          self.ex = TransactionServiceException()
19351 
          self.ex.read(iprot)
19352 
        else:
19353 
          iprot.skip(ftype)
19354 
      else:
19355 
        iprot.skip(ftype)
19356 
      iprot.readFieldEnd()
19357 
    iprot.readStructEnd()
19358 
 
19359 
  def write(self, oprot):
19360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19362 
      return
19363 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
19364 
    if self.success is not None:
19365 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19366 
      oprot.writeBool(self.success)
19367 
      oprot.writeFieldEnd()
19368 
    if self.ex is not None:
19369 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19370 
      self.ex.write(oprot)
19371 
      oprot.writeFieldEnd()
19372 
    oprot.writeFieldStop()
19373 
    oprot.writeStructEnd()
19374 
 
19375 
  def validate(self):
19376 
    return
19377 
 
19378 
 
19379 
  def __repr__(self):
19380 
    L = ['%s=%r' % (key, value)
19381 
      for key, value in self.__dict__.iteritems()]
19382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19383 
 
19384 
  def __eq__(self, other):
19385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19386 
 
19387 
  def __ne__(self, other):
19388 
    return not (self == other)
19389 
 
4386 anupam.sin 19390 
class getOrderForAwb_args:
19391 
  """
19392 
  Attributes:
19393 
   - awb
19394 
  """
19395 
 
19396 
  thrift_spec = (
19397 
    None, # 0
19398 
    (1, TType.STRING, 'awb', None, None, ), # 1
19399 
  )
19400 
 
19401 
  def __init__(self, awb=None,):
19402 
    self.awb = awb
19403 
 
19404 
  def read(self, iprot):
19405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19407 
      return
19408 
    iprot.readStructBegin()
19409 
    while True:
19410 
      (fname, ftype, fid) = iprot.readFieldBegin()
19411 
      if ftype == TType.STOP:
19412 
        break
19413 
      if fid == 1:
19414 
        if ftype == TType.STRING:
19415 
          self.awb = iprot.readString();
19416 
        else:
19417 
          iprot.skip(ftype)
19418 
      else:
19419 
        iprot.skip(ftype)
19420 
      iprot.readFieldEnd()
19421 
    iprot.readStructEnd()
19422 
 
19423 
  def write(self, oprot):
19424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19426 
      return
19427 
    oprot.writeStructBegin('getOrderForAwb_args')
19428 
    if self.awb is not None:
19429 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
19430 
      oprot.writeString(self.awb)
19431 
      oprot.writeFieldEnd()
19432 
    oprot.writeFieldStop()
19433 
    oprot.writeStructEnd()
19434 
 
19435 
  def validate(self):
19436 
    return
19437 
 
19438 
 
19439 
  def __repr__(self):
19440 
    L = ['%s=%r' % (key, value)
19441 
      for key, value in self.__dict__.iteritems()]
19442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19443 
 
19444 
  def __eq__(self, other):
19445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19446 
 
19447 
  def __ne__(self, other):
19448 
    return not (self == other)
19449 
 
19450 
class getOrderForAwb_result:
19451 
  """
19452 
  Attributes:
19453 
   - success
19454 
   - ex
19455 
  """
19456 
 
19457 
  thrift_spec = (
19458 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19459 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19460 
  )
19461 
 
19462 
  def __init__(self, success=None, ex=None,):
19463 
    self.success = success
19464 
    self.ex = ex
19465 
 
19466 
  def read(self, iprot):
19467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19469 
      return
19470 
    iprot.readStructBegin()
19471 
    while True:
19472 
      (fname, ftype, fid) = iprot.readFieldBegin()
19473 
      if ftype == TType.STOP:
19474 
        break
19475 
      if fid == 0:
19476 
        if ftype == TType.STRUCT:
19477 
          self.success = Order()
19478 
          self.success.read(iprot)
19479 
        else:
19480 
          iprot.skip(ftype)
19481 
      elif fid == 1:
19482 
        if ftype == TType.STRUCT:
19483 
          self.ex = TransactionServiceException()
19484 
          self.ex.read(iprot)
19485 
        else:
19486 
          iprot.skip(ftype)
19487 
      else:
19488 
        iprot.skip(ftype)
19489 
      iprot.readFieldEnd()
19490 
    iprot.readStructEnd()
19491 
 
19492 
  def write(self, oprot):
19493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19495 
      return
19496 
    oprot.writeStructBegin('getOrderForAwb_result')
19497 
    if self.success is not None:
19498 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19499 
      self.success.write(oprot)
19500 
      oprot.writeFieldEnd()
19501 
    if self.ex is not None:
19502 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19503 
      self.ex.write(oprot)
19504 
      oprot.writeFieldEnd()
19505 
    oprot.writeFieldStop()
19506 
    oprot.writeStructEnd()
19507 
 
19508 
  def validate(self):
19509 
    return
19510 
 
19511 
 
19512 
  def __repr__(self):
19513 
    L = ['%s=%r' % (key, value)
19514 
      for key, value in self.__dict__.iteritems()]
19515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19516 
 
19517 
  def __eq__(self, other):
19518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19519 
 
19520 
  def __ne__(self, other):
19521 
    return not (self == other)
4506 phani.kuma 19522 
 
19523 
class getOrdersForProviderForStatus_args:
19524 
  """
19525 
  Attributes:
19526 
   - logistics_provider_id
4910 phani.kuma 19527 
   - order_status_list
4506 phani.kuma 19528 
  """
19529 
 
19530 
  thrift_spec = (
19531 
    None, # 0
19532 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 19533 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 19534 
  )
19535 
 
4910 phani.kuma 19536 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 19537 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 19538 
    self.order_status_list = order_status_list
4506 phani.kuma 19539 
 
19540 
  def read(self, iprot):
19541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19543 
      return
19544 
    iprot.readStructBegin()
19545 
    while True:
19546 
      (fname, ftype, fid) = iprot.readFieldBegin()
19547 
      if ftype == TType.STOP:
19548 
        break
19549 
      if fid == 1:
19550 
        if ftype == TType.I64:
19551 
          self.logistics_provider_id = iprot.readI64();
19552 
        else:
19553 
          iprot.skip(ftype)
19554 
      elif fid == 2:
4910 phani.kuma 19555 
        if ftype == TType.LIST:
19556 
          self.order_status_list = []
5031 varun.gupt 19557 
          (_etype421, _size418) = iprot.readListBegin()
19558 
          for _i422 in xrange(_size418):
19559 
            _elem423 = iprot.readI32();
19560 
            self.order_status_list.append(_elem423)
4910 phani.kuma 19561 
          iprot.readListEnd()
4506 phani.kuma 19562 
        else:
19563 
          iprot.skip(ftype)
19564 
      else:
19565 
        iprot.skip(ftype)
19566 
      iprot.readFieldEnd()
19567 
    iprot.readStructEnd()
19568 
 
19569 
  def write(self, oprot):
19570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19572 
      return
19573 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
19574 
    if self.logistics_provider_id is not None:
19575 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
19576 
      oprot.writeI64(self.logistics_provider_id)
19577 
      oprot.writeFieldEnd()
4910 phani.kuma 19578 
    if self.order_status_list is not None:
19579 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
19580 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
5031 varun.gupt 19581 
      for iter424 in self.order_status_list:
19582 
        oprot.writeI32(iter424)
4910 phani.kuma 19583 
      oprot.writeListEnd()
4506 phani.kuma 19584 
      oprot.writeFieldEnd()
19585 
    oprot.writeFieldStop()
19586 
    oprot.writeStructEnd()
19587 
 
19588 
  def validate(self):
19589 
    return
19590 
 
19591 
 
19592 
  def __repr__(self):
19593 
    L = ['%s=%r' % (key, value)
19594 
      for key, value in self.__dict__.iteritems()]
19595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19596 
 
19597 
  def __eq__(self, other):
19598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19599 
 
19600 
  def __ne__(self, other):
19601 
    return not (self == other)
19602 
 
19603 
class getOrdersForProviderForStatus_result:
19604 
  """
19605 
  Attributes:
19606 
   - success
19607 
   - ex
19608 
  """
19609 
 
19610 
  thrift_spec = (
19611 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19612 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19613 
  )
19614 
 
19615 
  def __init__(self, success=None, ex=None,):
19616 
    self.success = success
19617 
    self.ex = ex
19618 
 
19619 
  def read(self, iprot):
19620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19622 
      return
19623 
    iprot.readStructBegin()
19624 
    while True:
19625 
      (fname, ftype, fid) = iprot.readFieldBegin()
19626 
      if ftype == TType.STOP:
19627 
        break
19628 
      if fid == 0:
19629 
        if ftype == TType.LIST:
19630 
          self.success = []
5031 varun.gupt 19631 
          (_etype428, _size425) = iprot.readListBegin()
19632 
          for _i429 in xrange(_size425):
19633 
            _elem430 = Order()
19634 
            _elem430.read(iprot)
19635 
            self.success.append(_elem430)
4506 phani.kuma 19636 
          iprot.readListEnd()
19637 
        else:
19638 
          iprot.skip(ftype)
19639 
      elif fid == 1:
19640 
        if ftype == TType.STRUCT:
19641 
          self.ex = TransactionServiceException()
19642 
          self.ex.read(iprot)
19643 
        else:
19644 
          iprot.skip(ftype)
19645 
      else:
19646 
        iprot.skip(ftype)
19647 
      iprot.readFieldEnd()
19648 
    iprot.readStructEnd()
19649 
 
19650 
  def write(self, oprot):
19651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19653 
      return
19654 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
19655 
    if self.success is not None:
19656 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19657 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19658 
      for iter431 in self.success:
19659 
        iter431.write(oprot)
4506 phani.kuma 19660 
      oprot.writeListEnd()
19661 
      oprot.writeFieldEnd()
19662 
    if self.ex is not None:
19663 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19664 
      self.ex.write(oprot)
19665 
      oprot.writeFieldEnd()
19666 
    oprot.writeFieldStop()
19667 
    oprot.writeStructEnd()
19668 
 
19669 
  def validate(self):
19670 
    return
19671 
 
19672 
 
19673 
  def __repr__(self):
19674 
    L = ['%s=%r' % (key, value)
19675 
      for key, value in self.__dict__.iteritems()]
19676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19677 
 
19678 
  def __eq__(self, other):
19679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19680 
 
19681 
  def __ne__(self, other):
19682 
    return not (self == other)
4600 varun.gupt 19683 
 
19684 
class getBilledOrdersForVendor_args:
19685 
  """
19686 
  Attributes:
19687 
   - vendorId
19688 
   - billingDateFrom
19689 
   - billingDateTo
19690 
  """
19691 
 
19692 
  thrift_spec = (
19693 
    None, # 0
19694 
    (1, TType.I64, 'vendorId', None, None, ), # 1
19695 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
19696 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
19697 
  )
19698 
 
19699 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
19700 
    self.vendorId = vendorId
19701 
    self.billingDateFrom = billingDateFrom
19702 
    self.billingDateTo = billingDateTo
19703 
 
19704 
  def read(self, iprot):
19705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19707 
      return
19708 
    iprot.readStructBegin()
19709 
    while True:
19710 
      (fname, ftype, fid) = iprot.readFieldBegin()
19711 
      if ftype == TType.STOP:
19712 
        break
19713 
      if fid == 1:
19714 
        if ftype == TType.I64:
19715 
          self.vendorId = iprot.readI64();
19716 
        else:
19717 
          iprot.skip(ftype)
19718 
      elif fid == 2:
19719 
        if ftype == TType.I64:
19720 
          self.billingDateFrom = iprot.readI64();
19721 
        else:
19722 
          iprot.skip(ftype)
19723 
      elif fid == 3:
19724 
        if ftype == TType.I64:
19725 
          self.billingDateTo = iprot.readI64();
19726 
        else:
19727 
          iprot.skip(ftype)
19728 
      else:
19729 
        iprot.skip(ftype)
19730 
      iprot.readFieldEnd()
19731 
    iprot.readStructEnd()
19732 
 
19733 
  def write(self, oprot):
19734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19736 
      return
19737 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
19738 
    if self.vendorId is not None:
19739 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
19740 
      oprot.writeI64(self.vendorId)
19741 
      oprot.writeFieldEnd()
19742 
    if self.billingDateFrom is not None:
19743 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
19744 
      oprot.writeI64(self.billingDateFrom)
19745 
      oprot.writeFieldEnd()
19746 
    if self.billingDateTo is not None:
19747 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
19748 
      oprot.writeI64(self.billingDateTo)
19749 
      oprot.writeFieldEnd()
19750 
    oprot.writeFieldStop()
19751 
    oprot.writeStructEnd()
19752 
 
19753 
  def validate(self):
19754 
    return
19755 
 
19756 
 
19757 
  def __repr__(self):
19758 
    L = ['%s=%r' % (key, value)
19759 
      for key, value in self.__dict__.iteritems()]
19760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19761 
 
19762 
  def __eq__(self, other):
19763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19764 
 
19765 
  def __ne__(self, other):
19766 
    return not (self == other)
19767 
 
19768 
class getBilledOrdersForVendor_result:
19769 
  """
19770 
  Attributes:
19771 
   - success
19772 
   - ex
19773 
  """
19774 
 
19775 
  thrift_spec = (
19776 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19777 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19778 
  )
19779 
 
19780 
  def __init__(self, success=None, ex=None,):
19781 
    self.success = success
19782 
    self.ex = ex
19783 
 
19784 
  def read(self, iprot):
19785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19787 
      return
19788 
    iprot.readStructBegin()
19789 
    while True:
19790 
      (fname, ftype, fid) = iprot.readFieldBegin()
19791 
      if ftype == TType.STOP:
19792 
        break
19793 
      if fid == 0:
19794 
        if ftype == TType.LIST:
19795 
          self.success = []
5031 varun.gupt 19796 
          (_etype435, _size432) = iprot.readListBegin()
19797 
          for _i436 in xrange(_size432):
19798 
            _elem437 = Order()
19799 
            _elem437.read(iprot)
19800 
            self.success.append(_elem437)
4600 varun.gupt 19801 
          iprot.readListEnd()
19802 
        else:
19803 
          iprot.skip(ftype)
19804 
      elif fid == 1:
19805 
        if ftype == TType.STRUCT:
19806 
          self.ex = TransactionServiceException()
19807 
          self.ex.read(iprot)
19808 
        else:
19809 
          iprot.skip(ftype)
19810 
      else:
19811 
        iprot.skip(ftype)
19812 
      iprot.readFieldEnd()
19813 
    iprot.readStructEnd()
19814 
 
19815 
  def write(self, oprot):
19816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19818 
      return
19819 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
19820 
    if self.success is not None:
19821 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19822 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19823 
      for iter438 in self.success:
19824 
        iter438.write(oprot)
4600 varun.gupt 19825 
      oprot.writeListEnd()
19826 
      oprot.writeFieldEnd()
19827 
    if self.ex is not None:
19828 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19829 
      self.ex.write(oprot)
19830 
      oprot.writeFieldEnd()
19831 
    oprot.writeFieldStop()
19832 
    oprot.writeStructEnd()
19833 
 
19834 
  def validate(self):
19835 
    return
19836 
 
19837 
 
19838 
  def __repr__(self):
19839 
    L = ['%s=%r' % (key, value)
19840 
      for key, value in self.__dict__.iteritems()]
19841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19842 
 
19843 
  def __eq__(self, other):
19844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19845 
 
19846 
  def __ne__(self, other):
19847 
    return not (self == other)
19848 
 
4607 rajveer 19849 
class getSlippedSippingDateOrders_args:
19850 
 
19851 
  thrift_spec = (
19852 
  )
19853 
 
19854 
  def read(self, iprot):
19855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19857 
      return
19858 
    iprot.readStructBegin()
19859 
    while True:
19860 
      (fname, ftype, fid) = iprot.readFieldBegin()
19861 
      if ftype == TType.STOP:
19862 
        break
19863 
      else:
19864 
        iprot.skip(ftype)
19865 
      iprot.readFieldEnd()
19866 
    iprot.readStructEnd()
19867 
 
19868 
  def write(self, oprot):
19869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19871 
      return
19872 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
19873 
    oprot.writeFieldStop()
19874 
    oprot.writeStructEnd()
19875 
 
19876 
  def validate(self):
19877 
    return
19878 
 
19879 
 
19880 
  def __repr__(self):
19881 
    L = ['%s=%r' % (key, value)
19882 
      for key, value in self.__dict__.iteritems()]
19883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19884 
 
19885 
  def __eq__(self, other):
19886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19887 
 
19888 
  def __ne__(self, other):
19889 
    return not (self == other)
19890 
 
19891 
class getSlippedSippingDateOrders_result:
19892 
  """
19893 
  Attributes:
19894 
   - success
19895 
   - ex
19896 
  """
19897 
 
19898 
  thrift_spec = (
19899 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19900 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19901 
  )
19902 
 
19903 
  def __init__(self, success=None, ex=None,):
19904 
    self.success = success
19905 
    self.ex = ex
19906 
 
19907 
  def read(self, iprot):
19908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19910 
      return
19911 
    iprot.readStructBegin()
19912 
    while True:
19913 
      (fname, ftype, fid) = iprot.readFieldBegin()
19914 
      if ftype == TType.STOP:
19915 
        break
19916 
      if fid == 0:
19917 
        if ftype == TType.LIST:
19918 
          self.success = []
5031 varun.gupt 19919 
          (_etype442, _size439) = iprot.readListBegin()
19920 
          for _i443 in xrange(_size439):
19921 
            _elem444 = Order()
19922 
            _elem444.read(iprot)
19923 
            self.success.append(_elem444)
4607 rajveer 19924 
          iprot.readListEnd()
19925 
        else:
19926 
          iprot.skip(ftype)
19927 
      elif fid == 1:
19928 
        if ftype == TType.STRUCT:
19929 
          self.ex = TransactionServiceException()
19930 
          self.ex.read(iprot)
19931 
        else:
19932 
          iprot.skip(ftype)
19933 
      else:
19934 
        iprot.skip(ftype)
19935 
      iprot.readFieldEnd()
19936 
    iprot.readStructEnd()
19937 
 
19938 
  def write(self, oprot):
19939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19941 
      return
19942 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
19943 
    if self.success is not None:
19944 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19945 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 19946 
      for iter445 in self.success:
19947 
        iter445.write(oprot)
4607 rajveer 19948 
      oprot.writeListEnd()
19949 
      oprot.writeFieldEnd()
19950 
    if self.ex is not None:
19951 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19952 
      self.ex.write(oprot)
19953 
      oprot.writeFieldEnd()
19954 
    oprot.writeFieldStop()
19955 
    oprot.writeStructEnd()
19956 
 
19957 
  def validate(self):
19958 
    return
19959 
 
19960 
 
19961 
  def __repr__(self):
19962 
    L = ['%s=%r' % (key, value)
19963 
      for key, value in self.__dict__.iteritems()]
19964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19965 
 
19966 
  def __eq__(self, other):
19967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19968 
 
19969 
  def __ne__(self, other):
19970 
    return not (self == other)
19971 
 
4709 rajveer 19972 
class getCancelledOrders_args:
19973 
  """
19974 
  Attributes:
19975 
   - cancelDateFrom
19976 
   - cancelDateTo
19977 
  """
19978 
 
19979 
  thrift_spec = (
19980 
    None, # 0
19981 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
19982 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
19983 
  )
19984 
 
19985 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
19986 
    self.cancelDateFrom = cancelDateFrom
19987 
    self.cancelDateTo = cancelDateTo
19988 
 
19989 
  def read(self, iprot):
19990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19992 
      return
19993 
    iprot.readStructBegin()
19994 
    while True:
19995 
      (fname, ftype, fid) = iprot.readFieldBegin()
19996 
      if ftype == TType.STOP:
19997 
        break
19998 
      if fid == 1:
19999 
        if ftype == TType.I64:
20000 
          self.cancelDateFrom = iprot.readI64();
20001 
        else:
20002 
          iprot.skip(ftype)
20003 
      elif fid == 2:
20004 
        if ftype == TType.I64:
20005 
          self.cancelDateTo = iprot.readI64();
20006 
        else:
20007 
          iprot.skip(ftype)
20008 
      else:
20009 
        iprot.skip(ftype)
20010 
      iprot.readFieldEnd()
20011 
    iprot.readStructEnd()
20012 
 
20013 
  def write(self, oprot):
20014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20016 
      return
20017 
    oprot.writeStructBegin('getCancelledOrders_args')
20018 
    if self.cancelDateFrom is not None:
20019 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
20020 
      oprot.writeI64(self.cancelDateFrom)
20021 
      oprot.writeFieldEnd()
20022 
    if self.cancelDateTo is not None:
20023 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
20024 
      oprot.writeI64(self.cancelDateTo)
20025 
      oprot.writeFieldEnd()
20026 
    oprot.writeFieldStop()
20027 
    oprot.writeStructEnd()
20028 
 
20029 
  def validate(self):
20030 
    return
20031 
 
20032 
 
20033 
  def __repr__(self):
20034 
    L = ['%s=%r' % (key, value)
20035 
      for key, value in self.__dict__.iteritems()]
20036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20037 
 
20038 
  def __eq__(self, other):
20039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20040 
 
20041 
  def __ne__(self, other):
20042 
    return not (self == other)
20043 
 
20044 
class getCancelledOrders_result:
20045 
  """
20046 
  Attributes:
20047 
   - success
20048 
   - ex
20049 
  """
20050 
 
20051 
  thrift_spec = (
20052 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20053 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20054 
  )
20055 
 
20056 
  def __init__(self, success=None, ex=None,):
20057 
    self.success = success
20058 
    self.ex = ex
20059 
 
20060 
  def read(self, iprot):
20061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20063 
      return
20064 
    iprot.readStructBegin()
20065 
    while True:
20066 
      (fname, ftype, fid) = iprot.readFieldBegin()
20067 
      if ftype == TType.STOP:
20068 
        break
20069 
      if fid == 0:
20070 
        if ftype == TType.LIST:
20071 
          self.success = []
5031 varun.gupt 20072 
          (_etype449, _size446) = iprot.readListBegin()
20073 
          for _i450 in xrange(_size446):
20074 
            _elem451 = Order()
20075 
            _elem451.read(iprot)
20076 
            self.success.append(_elem451)
4709 rajveer 20077 
          iprot.readListEnd()
20078 
        else:
20079 
          iprot.skip(ftype)
20080 
      elif fid == 1:
20081 
        if ftype == TType.STRUCT:
20082 
          self.ex = TransactionServiceException()
20083 
          self.ex.read(iprot)
20084 
        else:
20085 
          iprot.skip(ftype)
20086 
      else:
20087 
        iprot.skip(ftype)
20088 
      iprot.readFieldEnd()
20089 
    iprot.readStructEnd()
20090 
 
20091 
  def write(self, oprot):
20092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20094 
      return
20095 
    oprot.writeStructBegin('getCancelledOrders_result')
20096 
    if self.success is not None:
20097 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20098 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 20099 
      for iter452 in self.success:
20100 
        iter452.write(oprot)
4709 rajveer 20101 
      oprot.writeListEnd()
20102 
      oprot.writeFieldEnd()
20103 
    if self.ex is not None:
20104 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20105 
      self.ex.write(oprot)
20106 
      oprot.writeFieldEnd()
20107 
    oprot.writeFieldStop()
20108 
    oprot.writeStructEnd()
20109 
 
20110 
  def validate(self):
20111 
    return
20112 
 
20113 
 
20114 
  def __repr__(self):
20115 
    L = ['%s=%r' % (key, value)
20116 
      for key, value in self.__dict__.iteritems()]
20117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20118 
 
20119 
  def __eq__(self, other):
20120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20121 
 
20122 
  def __ne__(self, other):
20123 
    return not (self == other)
20124 
 
4600 varun.gupt 20125 
class saveBluedartSettlements_args:
20126 
  """
20127 
  Attributes:
20128 
   - mapAWBAndAmount
20129 
  """
20130 
 
20131 
  thrift_spec = (
20132 
    None, # 0
20133 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
20134 
  )
20135 
 
20136 
  def __init__(self, mapAWBAndAmount=None,):
20137 
    self.mapAWBAndAmount = mapAWBAndAmount
20138 
 
20139 
  def read(self, iprot):
20140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20142 
      return
20143 
    iprot.readStructBegin()
20144 
    while True:
20145 
      (fname, ftype, fid) = iprot.readFieldBegin()
20146 
      if ftype == TType.STOP:
20147 
        break
20148 
      if fid == 1:
20149 
        if ftype == TType.MAP:
20150 
          self.mapAWBAndAmount = {}
5031 varun.gupt 20151 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
20152 
          for _i457 in xrange(_size453):
20153 
            _key458 = iprot.readI64();
20154 
            _val459 = iprot.readDouble();
20155 
            self.mapAWBAndAmount[_key458] = _val459
4600 varun.gupt 20156 
          iprot.readMapEnd()
20157 
        else:
20158 
          iprot.skip(ftype)
20159 
      else:
20160 
        iprot.skip(ftype)
20161 
      iprot.readFieldEnd()
20162 
    iprot.readStructEnd()
20163 
 
20164 
  def write(self, oprot):
20165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20167 
      return
20168 
    oprot.writeStructBegin('saveBluedartSettlements_args')
20169 
    if self.mapAWBAndAmount is not None:
20170 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
20171 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
5031 varun.gupt 20172 
      for kiter460,viter461 in self.mapAWBAndAmount.items():
20173 
        oprot.writeI64(kiter460)
20174 
        oprot.writeDouble(viter461)
4600 varun.gupt 20175 
      oprot.writeMapEnd()
20176 
      oprot.writeFieldEnd()
20177 
    oprot.writeFieldStop()
20178 
    oprot.writeStructEnd()
20179 
 
20180 
  def validate(self):
20181 
    return
20182 
 
20183 
 
20184 
  def __repr__(self):
20185 
    L = ['%s=%r' % (key, value)
20186 
      for key, value in self.__dict__.iteritems()]
20187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20188 
 
20189 
  def __eq__(self, other):
20190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20191 
 
20192 
  def __ne__(self, other):
20193 
    return not (self == other)
20194 
 
20195 
class saveBluedartSettlements_result:
20196 
  """
20197 
  Attributes:
20198 
   - ex
20199 
  """
20200 
 
20201 
  thrift_spec = (
20202 
    None, # 0
20203 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20204 
  )
20205 
 
20206 
  def __init__(self, ex=None,):
20207 
    self.ex = ex
20208 
 
20209 
  def read(self, iprot):
20210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20212 
      return
20213 
    iprot.readStructBegin()
20214 
    while True:
20215 
      (fname, ftype, fid) = iprot.readFieldBegin()
20216 
      if ftype == TType.STOP:
20217 
        break
20218 
      if fid == 1:
20219 
        if ftype == TType.STRUCT:
20220 
          self.ex = TransactionServiceException()
20221 
          self.ex.read(iprot)
20222 
        else:
20223 
          iprot.skip(ftype)
20224 
      else:
20225 
        iprot.skip(ftype)
20226 
      iprot.readFieldEnd()
20227 
    iprot.readStructEnd()
20228 
 
20229 
  def write(self, oprot):
20230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20232 
      return
20233 
    oprot.writeStructBegin('saveBluedartSettlements_result')
20234 
    if self.ex is not None:
20235 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20236 
      self.ex.write(oprot)
20237 
      oprot.writeFieldEnd()
20238 
    oprot.writeFieldStop()
20239 
    oprot.writeStructEnd()
20240 
 
20241 
  def validate(self):
20242 
    return
20243 
 
20244 
 
20245 
  def __repr__(self):
20246 
    L = ['%s=%r' % (key, value)
20247 
      for key, value in self.__dict__.iteritems()]
20248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20249 
 
20250 
  def __eq__(self, other):
20251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20252 
 
20253 
  def __ne__(self, other):
20254 
    return not (self == other)
20255 
 
20256 
class savePaymentSettlements_args:
20257 
  """
20258 
  Attributes:
20259 
   - settlementDate
20260 
   - paymentGatewayId
4905 varun.gupt 20261 
   - referenceId
4600 varun.gupt 20262 
   - serviceTax
20263 
   - otherCharges
20264 
   - netCollection
20265 
  """
20266 
 
20267 
  thrift_spec = (
20268 
    None, # 0
20269 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
20270 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 20271 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 20272 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
20273 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
20274 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
20275 
  )
20276 
 
4905 varun.gupt 20277 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 20278 
    self.settlementDate = settlementDate
20279 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 20280 
    self.referenceId = referenceId
4600 varun.gupt 20281 
    self.serviceTax = serviceTax
20282 
    self.otherCharges = otherCharges
20283 
    self.netCollection = netCollection
20284 
 
20285 
  def read(self, iprot):
20286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20288 
      return
20289 
    iprot.readStructBegin()
20290 
    while True:
20291 
      (fname, ftype, fid) = iprot.readFieldBegin()
20292 
      if ftype == TType.STOP:
20293 
        break
20294 
      if fid == 1:
20295 
        if ftype == TType.I64:
20296 
          self.settlementDate = iprot.readI64();
20297 
        else:
20298 
          iprot.skip(ftype)
20299 
      elif fid == 2:
20300 
        if ftype == TType.I64:
20301 
          self.paymentGatewayId = iprot.readI64();
20302 
        else:
20303 
          iprot.skip(ftype)
20304 
      elif fid == 3:
20305 
        if ftype == TType.I64:
4905 varun.gupt 20306 
          self.referenceId = iprot.readI64();
4600 varun.gupt 20307 
        else:
20308 
          iprot.skip(ftype)
20309 
      elif fid == 4:
20310 
        if ftype == TType.DOUBLE:
20311 
          self.serviceTax = iprot.readDouble();
20312 
        else:
20313 
          iprot.skip(ftype)
20314 
      elif fid == 5:
20315 
        if ftype == TType.DOUBLE:
20316 
          self.otherCharges = iprot.readDouble();
20317 
        else:
20318 
          iprot.skip(ftype)
20319 
      elif fid == 6:
20320 
        if ftype == TType.DOUBLE:
20321 
          self.netCollection = iprot.readDouble();
20322 
        else:
20323 
          iprot.skip(ftype)
20324 
      else:
20325 
        iprot.skip(ftype)
20326 
      iprot.readFieldEnd()
20327 
    iprot.readStructEnd()
20328 
 
20329 
  def write(self, oprot):
20330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20332 
      return
20333 
    oprot.writeStructBegin('savePaymentSettlements_args')
20334 
    if self.settlementDate is not None:
20335 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
20336 
      oprot.writeI64(self.settlementDate)
20337 
      oprot.writeFieldEnd()
20338 
    if self.paymentGatewayId is not None:
20339 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
20340 
      oprot.writeI64(self.paymentGatewayId)
20341 
      oprot.writeFieldEnd()
4905 varun.gupt 20342 
    if self.referenceId is not None:
20343 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
20344 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 20345 
      oprot.writeFieldEnd()
20346 
    if self.serviceTax is not None:
20347 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
20348 
      oprot.writeDouble(self.serviceTax)
20349 
      oprot.writeFieldEnd()
20350 
    if self.otherCharges is not None:
20351 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
20352 
      oprot.writeDouble(self.otherCharges)
20353 
      oprot.writeFieldEnd()
20354 
    if self.netCollection is not None:
20355 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
20356 
      oprot.writeDouble(self.netCollection)
20357 
      oprot.writeFieldEnd()
20358 
    oprot.writeFieldStop()
20359 
    oprot.writeStructEnd()
20360 
 
20361 
  def validate(self):
20362 
    return
20363 
 
20364 
 
20365 
  def __repr__(self):
20366 
    L = ['%s=%r' % (key, value)
20367 
      for key, value in self.__dict__.iteritems()]
20368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20369 
 
20370 
  def __eq__(self, other):
20371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20372 
 
20373 
  def __ne__(self, other):
20374 
    return not (self == other)
20375 
 
20376 
class savePaymentSettlements_result:
20377 
  """
20378 
  Attributes:
20379 
   - ex
20380 
  """
20381 
 
20382 
  thrift_spec = (
20383 
    None, # 0
20384 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20385 
  )
20386 
 
20387 
  def __init__(self, ex=None,):
20388 
    self.ex = ex
20389 
 
20390 
  def read(self, iprot):
20391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20393 
      return
20394 
    iprot.readStructBegin()
20395 
    while True:
20396 
      (fname, ftype, fid) = iprot.readFieldBegin()
20397 
      if ftype == TType.STOP:
20398 
        break
20399 
      if fid == 1:
20400 
        if ftype == TType.STRUCT:
20401 
          self.ex = TransactionServiceException()
20402 
          self.ex.read(iprot)
20403 
        else:
20404 
          iprot.skip(ftype)
20405 
      else:
20406 
        iprot.skip(ftype)
20407 
      iprot.readFieldEnd()
20408 
    iprot.readStructEnd()
20409 
 
20410 
  def write(self, oprot):
20411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20413 
      return
20414 
    oprot.writeStructBegin('savePaymentSettlements_result')
20415 
    if self.ex is not None:
20416 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20417 
      self.ex.write(oprot)
20418 
      oprot.writeFieldEnd()
20419 
    oprot.writeFieldStop()
20420 
    oprot.writeStructEnd()
20421 
 
20422 
  def validate(self):
20423 
    return
20424 
 
20425 
 
20426 
  def __repr__(self):
20427 
    L = ['%s=%r' % (key, value)
20428 
      for key, value in self.__dict__.iteritems()]
20429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20430 
 
20431 
  def __eq__(self, other):
20432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20433 
 
20434 
  def __ne__(self, other):
20435 
    return not (self == other)
20436 
 
20437 
class saveEBSSettlementSummary_args:
20438 
  """
20439 
  Attributes:
20440 
   - settlementId
20441 
   - settlementDate
20442 
   - transactionDateFrom
20443 
   - transactionDateTo
20444 
   - amount
20445 
  """
20446 
 
20447 
  thrift_spec = (
20448 
    None, # 0
20449 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20450 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
20451 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
20452 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
20453 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
20454 
  )
20455 
 
20456 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
20457 
    self.settlementId = settlementId
20458 
    self.settlementDate = settlementDate
20459 
    self.transactionDateFrom = transactionDateFrom
20460 
    self.transactionDateTo = transactionDateTo
20461 
    self.amount = amount
20462 
 
20463 
  def read(self, iprot):
20464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20466 
      return
20467 
    iprot.readStructBegin()
20468 
    while True:
20469 
      (fname, ftype, fid) = iprot.readFieldBegin()
20470 
      if ftype == TType.STOP:
20471 
        break
20472 
      if fid == 1:
20473 
        if ftype == TType.I64:
20474 
          self.settlementId = iprot.readI64();
20475 
        else:
20476 
          iprot.skip(ftype)
20477 
      elif fid == 2:
20478 
        if ftype == TType.I64:
20479 
          self.settlementDate = iprot.readI64();
20480 
        else:
20481 
          iprot.skip(ftype)
20482 
      elif fid == 3:
20483 
        if ftype == TType.I64:
20484 
          self.transactionDateFrom = iprot.readI64();
20485 
        else:
20486 
          iprot.skip(ftype)
20487 
      elif fid == 4:
20488 
        if ftype == TType.I64:
20489 
          self.transactionDateTo = iprot.readI64();
20490 
        else:
20491 
          iprot.skip(ftype)
20492 
      elif fid == 5:
20493 
        if ftype == TType.DOUBLE:
20494 
          self.amount = iprot.readDouble();
20495 
        else:
20496 
          iprot.skip(ftype)
20497 
      else:
20498 
        iprot.skip(ftype)
20499 
      iprot.readFieldEnd()
20500 
    iprot.readStructEnd()
20501 
 
20502 
  def write(self, oprot):
20503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20505 
      return
20506 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
20507 
    if self.settlementId is not None:
20508 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20509 
      oprot.writeI64(self.settlementId)
20510 
      oprot.writeFieldEnd()
20511 
    if self.settlementDate is not None:
20512 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
20513 
      oprot.writeI64(self.settlementDate)
20514 
      oprot.writeFieldEnd()
20515 
    if self.transactionDateFrom is not None:
20516 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
20517 
      oprot.writeI64(self.transactionDateFrom)
20518 
      oprot.writeFieldEnd()
20519 
    if self.transactionDateTo is not None:
20520 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
20521 
      oprot.writeI64(self.transactionDateTo)
20522 
      oprot.writeFieldEnd()
20523 
    if self.amount is not None:
20524 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
20525 
      oprot.writeDouble(self.amount)
20526 
      oprot.writeFieldEnd()
20527 
    oprot.writeFieldStop()
20528 
    oprot.writeStructEnd()
20529 
 
20530 
  def validate(self):
20531 
    return
20532 
 
20533 
 
20534 
  def __repr__(self):
20535 
    L = ['%s=%r' % (key, value)
20536 
      for key, value in self.__dict__.iteritems()]
20537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20538 
 
20539 
  def __eq__(self, other):
20540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20541 
 
20542 
  def __ne__(self, other):
20543 
    return not (self == other)
20544 
 
20545 
class saveEBSSettlementSummary_result:
20546 
  """
20547 
  Attributes:
20548 
   - ex
20549 
  """
20550 
 
20551 
  thrift_spec = (
20552 
    None, # 0
20553 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20554 
  )
20555 
 
20556 
  def __init__(self, ex=None,):
20557 
    self.ex = ex
20558 
 
20559 
  def read(self, iprot):
20560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20562 
      return
20563 
    iprot.readStructBegin()
20564 
    while True:
20565 
      (fname, ftype, fid) = iprot.readFieldBegin()
20566 
      if ftype == TType.STOP:
20567 
        break
20568 
      if fid == 1:
20569 
        if ftype == TType.STRUCT:
20570 
          self.ex = TransactionServiceException()
20571 
          self.ex.read(iprot)
20572 
        else:
20573 
          iprot.skip(ftype)
20574 
      else:
20575 
        iprot.skip(ftype)
20576 
      iprot.readFieldEnd()
20577 
    iprot.readStructEnd()
20578 
 
20579 
  def write(self, oprot):
20580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20582 
      return
20583 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
20584 
    if self.ex is not None:
20585 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20586 
      self.ex.write(oprot)
20587 
      oprot.writeFieldEnd()
20588 
    oprot.writeFieldStop()
20589 
    oprot.writeStructEnd()
20590 
 
20591 
  def validate(self):
20592 
    return
20593 
 
20594 
 
20595 
  def __repr__(self):
20596 
    L = ['%s=%r' % (key, value)
20597 
      for key, value in self.__dict__.iteritems()]
20598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20599 
 
20600 
  def __eq__(self, other):
20601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20602 
 
20603 
  def __ne__(self, other):
20604 
    return not (self == other)
20605 
 
5189 varun.gupt 20606 
class getSettlementForReferenceId_args:
4600 varun.gupt 20607 
  """
20608 
  Attributes:
5189 varun.gupt 20609 
   - referenceId
20610 
   - isRefund
4600 varun.gupt 20611 
  """
20612 
 
20613 
  thrift_spec = (
20614 
    None, # 0
5189 varun.gupt 20615 
    (1, TType.I64, 'referenceId', None, None, ), # 1
20616 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 20617 
  )
20618 
 
5189 varun.gupt 20619 
  def __init__(self, referenceId=None, isRefund=None,):
20620 
    self.referenceId = referenceId
20621 
    self.isRefund = isRefund
4600 varun.gupt 20622 
 
20623 
  def read(self, iprot):
20624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20626 
      return
20627 
    iprot.readStructBegin()
20628 
    while True:
20629 
      (fname, ftype, fid) = iprot.readFieldBegin()
20630 
      if ftype == TType.STOP:
20631 
        break
20632 
      if fid == 1:
20633 
        if ftype == TType.I64:
5189 varun.gupt 20634 
          self.referenceId = iprot.readI64();
4600 varun.gupt 20635 
        else:
20636 
          iprot.skip(ftype)
5189 varun.gupt 20637 
      elif fid == 2:
20638 
        if ftype == TType.BOOL:
20639 
          self.isRefund = iprot.readBool();
20640 
        else:
20641 
          iprot.skip(ftype)
4600 varun.gupt 20642 
      else:
20643 
        iprot.skip(ftype)
20644 
      iprot.readFieldEnd()
20645 
    iprot.readStructEnd()
20646 
 
20647 
  def write(self, oprot):
20648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20650 
      return
5189 varun.gupt 20651 
    oprot.writeStructBegin('getSettlementForReferenceId_args')
20652 
    if self.referenceId is not None:
20653 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
20654 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 20655 
      oprot.writeFieldEnd()
5189 varun.gupt 20656 
    if self.isRefund is not None:
20657 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
20658 
      oprot.writeBool(self.isRefund)
20659 
      oprot.writeFieldEnd()
4600 varun.gupt 20660 
    oprot.writeFieldStop()
20661 
    oprot.writeStructEnd()
20662 
 
20663 
  def validate(self):
20664 
    return
20665 
 
20666 
 
20667 
  def __repr__(self):
20668 
    L = ['%s=%r' % (key, value)
20669 
      for key, value in self.__dict__.iteritems()]
20670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20671 
 
20672 
  def __eq__(self, other):
20673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20674 
 
20675 
  def __ne__(self, other):
20676 
    return not (self == other)
20677 
 
5189 varun.gupt 20678 
class getSettlementForReferenceId_result:
4600 varun.gupt 20679 
  """
20680 
  Attributes:
20681 
   - success
20682 
   - ex
20683 
  """
20684 
 
20685 
  thrift_spec = (
20686 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
20687 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20688 
  )
20689 
 
20690 
  def __init__(self, success=None, ex=None,):
20691 
    self.success = success
20692 
    self.ex = ex
20693 
 
20694 
  def read(self, iprot):
20695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20697 
      return
20698 
    iprot.readStructBegin()
20699 
    while True:
20700 
      (fname, ftype, fid) = iprot.readFieldBegin()
20701 
      if ftype == TType.STOP:
20702 
        break
20703 
      if fid == 0:
20704 
        if ftype == TType.STRUCT:
20705 
          self.success = PaymentSettlement()
20706 
          self.success.read(iprot)
20707 
        else:
20708 
          iprot.skip(ftype)
20709 
      elif fid == 1:
20710 
        if ftype == TType.STRUCT:
20711 
          self.ex = TransactionServiceException()
20712 
          self.ex.read(iprot)
20713 
        else:
20714 
          iprot.skip(ftype)
20715 
      else:
20716 
        iprot.skip(ftype)
20717 
      iprot.readFieldEnd()
20718 
    iprot.readStructEnd()
20719 
 
20720 
  def write(self, oprot):
20721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20723 
      return
5189 varun.gupt 20724 
    oprot.writeStructBegin('getSettlementForReferenceId_result')
4600 varun.gupt 20725 
    if self.success is not None:
20726 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20727 
      self.success.write(oprot)
20728 
      oprot.writeFieldEnd()
20729 
    if self.ex is not None:
20730 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20731 
      self.ex.write(oprot)
20732 
      oprot.writeFieldEnd()
20733 
    oprot.writeFieldStop()
20734 
    oprot.writeStructEnd()
20735 
 
20736 
  def validate(self):
20737 
    return
20738 
 
20739 
 
20740 
  def __repr__(self):
20741 
    L = ['%s=%r' % (key, value)
20742 
      for key, value in self.__dict__.iteritems()]
20743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20744 
 
20745 
  def __eq__(self, other):
20746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20747 
 
20748 
  def __ne__(self, other):
20749 
    return not (self == other)
20750 
 
20751 
class getEBSSettlementSummaries_args:
20752 
 
20753 
  thrift_spec = (
20754 
  )
20755 
 
20756 
  def read(self, iprot):
20757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20759 
      return
20760 
    iprot.readStructBegin()
20761 
    while True:
20762 
      (fname, ftype, fid) = iprot.readFieldBegin()
20763 
      if ftype == TType.STOP:
20764 
        break
20765 
      else:
20766 
        iprot.skip(ftype)
20767 
      iprot.readFieldEnd()
20768 
    iprot.readStructEnd()
20769 
 
20770 
  def write(self, oprot):
20771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20773 
      return
20774 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
20775 
    oprot.writeFieldStop()
20776 
    oprot.writeStructEnd()
20777 
 
20778 
  def validate(self):
20779 
    return
20780 
 
20781 
 
20782 
  def __repr__(self):
20783 
    L = ['%s=%r' % (key, value)
20784 
      for key, value in self.__dict__.iteritems()]
20785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20786 
 
20787 
  def __eq__(self, other):
20788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20789 
 
20790 
  def __ne__(self, other):
20791 
    return not (self == other)
20792 
 
20793 
class getEBSSettlementSummaries_result:
20794 
  """
20795 
  Attributes:
20796 
   - success
20797 
   - ex
20798 
  """
20799 
 
20800 
  thrift_spec = (
20801 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
20802 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20803 
  )
20804 
 
20805 
  def __init__(self, success=None, ex=None,):
20806 
    self.success = success
20807 
    self.ex = ex
20808 
 
20809 
  def read(self, iprot):
20810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20812 
      return
20813 
    iprot.readStructBegin()
20814 
    while True:
20815 
      (fname, ftype, fid) = iprot.readFieldBegin()
20816 
      if ftype == TType.STOP:
20817 
        break
20818 
      if fid == 0:
20819 
        if ftype == TType.MAP:
20820 
          self.success = {}
5031 varun.gupt 20821 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20822 
          for _i466 in xrange(_size462):
20823 
            _key467 = iprot.readI64();
20824 
            _val468 = iprot.readString();
20825 
            self.success[_key467] = _val468
4600 varun.gupt 20826 
          iprot.readMapEnd()
20827 
        else:
20828 
          iprot.skip(ftype)
20829 
      elif fid == 1:
20830 
        if ftype == TType.STRUCT:
20831 
          self.ex = TransactionServiceException()
20832 
          self.ex.read(iprot)
20833 
        else:
20834 
          iprot.skip(ftype)
20835 
      else:
20836 
        iprot.skip(ftype)
20837 
      iprot.readFieldEnd()
20838 
    iprot.readStructEnd()
20839 
 
20840 
  def write(self, oprot):
20841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20843 
      return
20844 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
20845 
    if self.success is not None:
20846 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20847 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
5031 varun.gupt 20848 
      for kiter469,viter470 in self.success.items():
20849 
        oprot.writeI64(kiter469)
20850 
        oprot.writeString(viter470)
4600 varun.gupt 20851 
      oprot.writeMapEnd()
20852 
      oprot.writeFieldEnd()
20853 
    if self.ex is not None:
20854 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20855 
      self.ex.write(oprot)
20856 
      oprot.writeFieldEnd()
20857 
    oprot.writeFieldStop()
20858 
    oprot.writeStructEnd()
20859 
 
20860 
  def validate(self):
20861 
    return
20862 
 
20863 
 
20864 
  def __repr__(self):
20865 
    L = ['%s=%r' % (key, value)
20866 
      for key, value in self.__dict__.iteritems()]
20867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20868 
 
20869 
  def __eq__(self, other):
20870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20871 
 
20872 
  def __ne__(self, other):
20873 
    return not (self == other)
20874 
 
20875 
class markEBSSettlementUploaded_args:
20876 
  """
20877 
  Attributes:
20878 
   - settlementId
20879 
  """
20880 
 
20881 
  thrift_spec = (
20882 
    None, # 0
20883 
    (1, TType.I64, 'settlementId', None, None, ), # 1
20884 
  )
20885 
 
20886 
  def __init__(self, settlementId=None,):
20887 
    self.settlementId = settlementId
20888 
 
20889 
  def read(self, iprot):
20890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20892 
      return
20893 
    iprot.readStructBegin()
20894 
    while True:
20895 
      (fname, ftype, fid) = iprot.readFieldBegin()
20896 
      if ftype == TType.STOP:
20897 
        break
20898 
      if fid == 1:
20899 
        if ftype == TType.I64:
20900 
          self.settlementId = iprot.readI64();
20901 
        else:
20902 
          iprot.skip(ftype)
20903 
      else:
20904 
        iprot.skip(ftype)
20905 
      iprot.readFieldEnd()
20906 
    iprot.readStructEnd()
20907 
 
20908 
  def write(self, oprot):
20909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20911 
      return
20912 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
20913 
    if self.settlementId is not None:
20914 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
20915 
      oprot.writeI64(self.settlementId)
20916 
      oprot.writeFieldEnd()
20917 
    oprot.writeFieldStop()
20918 
    oprot.writeStructEnd()
20919 
 
20920 
  def validate(self):
20921 
    return
20922 
 
20923 
 
20924 
  def __repr__(self):
20925 
    L = ['%s=%r' % (key, value)
20926 
      for key, value in self.__dict__.iteritems()]
20927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20928 
 
20929 
  def __eq__(self, other):
20930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20931 
 
20932 
  def __ne__(self, other):
20933 
    return not (self == other)
20934 
 
20935 
class markEBSSettlementUploaded_result:
20936 
  """
20937 
  Attributes:
20938 
   - ex
20939 
  """
20940 
 
20941 
  thrift_spec = (
20942 
    None, # 0
20943 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20944 
  )
20945 
 
20946 
  def __init__(self, ex=None,):
20947 
    self.ex = ex
20948 
 
20949 
  def read(self, iprot):
20950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20952 
      return
20953 
    iprot.readStructBegin()
20954 
    while True:
20955 
      (fname, ftype, fid) = iprot.readFieldBegin()
20956 
      if ftype == TType.STOP:
20957 
        break
20958 
      if fid == 1:
20959 
        if ftype == TType.STRUCT:
20960 
          self.ex = TransactionServiceException()
20961 
          self.ex.read(iprot)
20962 
        else:
20963 
          iprot.skip(ftype)
20964 
      else:
20965 
        iprot.skip(ftype)
20966 
      iprot.readFieldEnd()
20967 
    iprot.readStructEnd()
20968 
 
20969 
  def write(self, oprot):
20970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20972 
      return
20973 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
20974 
    if self.ex is not None:
20975 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20976 
      self.ex.write(oprot)
20977 
      oprot.writeFieldEnd()
20978 
    oprot.writeFieldStop()
20979 
    oprot.writeStructEnd()
20980 
 
20981 
  def validate(self):
20982 
    return
20983 
 
20984 
 
20985 
  def __repr__(self):
20986 
    L = ['%s=%r' % (key, value)
20987 
      for key, value in self.__dict__.iteritems()]
20988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20989 
 
20990 
  def __eq__(self, other):
20991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20992 
 
20993 
  def __ne__(self, other):
20994 
    return not (self == other)
20995 
 
20996 
class getEBSSettlementDate_args:
20997 
  """
20998 
  Attributes:
20999 
   - settlementId
21000 
  """
21001 
 
21002 
  thrift_spec = (
21003 
    None, # 0
21004 
    (1, TType.I64, 'settlementId', None, None, ), # 1
21005 
  )
21006 
 
21007 
  def __init__(self, settlementId=None,):
21008 
    self.settlementId = settlementId
21009 
 
21010 
  def read(self, iprot):
21011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21013 
      return
21014 
    iprot.readStructBegin()
21015 
    while True:
21016 
      (fname, ftype, fid) = iprot.readFieldBegin()
21017 
      if ftype == TType.STOP:
21018 
        break
21019 
      if fid == 1:
21020 
        if ftype == TType.I64:
21021 
          self.settlementId = iprot.readI64();
21022 
        else:
21023 
          iprot.skip(ftype)
21024 
      else:
21025 
        iprot.skip(ftype)
21026 
      iprot.readFieldEnd()
21027 
    iprot.readStructEnd()
21028 
 
21029 
  def write(self, oprot):
21030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21032 
      return
21033 
    oprot.writeStructBegin('getEBSSettlementDate_args')
21034 
    if self.settlementId is not None:
21035 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
21036 
      oprot.writeI64(self.settlementId)
21037 
      oprot.writeFieldEnd()
21038 
    oprot.writeFieldStop()
21039 
    oprot.writeStructEnd()
21040 
 
21041 
  def validate(self):
21042 
    return
21043 
 
21044 
 
21045 
  def __repr__(self):
21046 
    L = ['%s=%r' % (key, value)
21047 
      for key, value in self.__dict__.iteritems()]
21048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21049 
 
21050 
  def __eq__(self, other):
21051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21052 
 
21053 
  def __ne__(self, other):
21054 
    return not (self == other)
21055 
 
21056 
class getEBSSettlementDate_result:
21057 
  """
21058 
  Attributes:
21059 
   - success
21060 
   - ex
21061 
  """
21062 
 
21063 
  thrift_spec = (
21064 
    (0, TType.I64, 'success', None, None, ), # 0
21065 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21066 
  )
21067 
 
21068 
  def __init__(self, success=None, ex=None,):
21069 
    self.success = success
21070 
    self.ex = ex
21071 
 
21072 
  def read(self, iprot):
21073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21075 
      return
21076 
    iprot.readStructBegin()
21077 
    while True:
21078 
      (fname, ftype, fid) = iprot.readFieldBegin()
21079 
      if ftype == TType.STOP:
21080 
        break
21081 
      if fid == 0:
21082 
        if ftype == TType.I64:
21083 
          self.success = iprot.readI64();
21084 
        else:
21085 
          iprot.skip(ftype)
21086 
      elif fid == 1:
21087 
        if ftype == TType.STRUCT:
21088 
          self.ex = TransactionServiceException()
21089 
          self.ex.read(iprot)
21090 
        else:
21091 
          iprot.skip(ftype)
21092 
      else:
21093 
        iprot.skip(ftype)
21094 
      iprot.readFieldEnd()
21095 
    iprot.readStructEnd()
21096 
 
21097 
  def write(self, oprot):
21098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21100 
      return
21101 
    oprot.writeStructBegin('getEBSSettlementDate_result')
21102 
    if self.success is not None:
21103 
      oprot.writeFieldBegin('success', TType.I64, 0)
21104 
      oprot.writeI64(self.success)
21105 
      oprot.writeFieldEnd()
21106 
    if self.ex is not None:
21107 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21108 
      self.ex.write(oprot)
21109 
      oprot.writeFieldEnd()
21110 
    oprot.writeFieldStop()
21111 
    oprot.writeStructEnd()
21112 
 
21113 
  def validate(self):
21114 
    return
21115 
 
21116 
 
21117 
  def __repr__(self):
21118 
    L = ['%s=%r' % (key, value)
21119 
      for key, value in self.__dict__.iteritems()]
21120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21121 
 
21122 
  def __eq__(self, other):
21123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21124 
 
21125 
  def __ne__(self, other):
21126 
    return not (self == other)
4715 varun.gupt 21127 
 
21128 
class getSettlementsByDate_args:
21129 
  """
21130 
  Attributes:
21131 
   - settlementDateFrom
21132 
   - settlementDateTo
21133 
   - isRefund
21134 
  """
21135 
 
21136 
  thrift_spec = (
21137 
    None, # 0
21138 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
21139 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
21140 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
21141 
  )
21142 
 
21143 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
21144 
    self.settlementDateFrom = settlementDateFrom
21145 
    self.settlementDateTo = settlementDateTo
21146 
    self.isRefund = isRefund
21147 
 
21148 
  def read(self, iprot):
21149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21151 
      return
21152 
    iprot.readStructBegin()
21153 
    while True:
21154 
      (fname, ftype, fid) = iprot.readFieldBegin()
21155 
      if ftype == TType.STOP:
21156 
        break
21157 
      if fid == 1:
21158 
        if ftype == TType.I64:
21159 
          self.settlementDateFrom = iprot.readI64();
21160 
        else:
21161 
          iprot.skip(ftype)
21162 
      elif fid == 2:
21163 
        if ftype == TType.I64:
21164 
          self.settlementDateTo = iprot.readI64();
21165 
        else:
21166 
          iprot.skip(ftype)
21167 
      elif fid == 3:
21168 
        if ftype == TType.BOOL:
21169 
          self.isRefund = iprot.readBool();
21170 
        else:
21171 
          iprot.skip(ftype)
21172 
      else:
21173 
        iprot.skip(ftype)
21174 
      iprot.readFieldEnd()
21175 
    iprot.readStructEnd()
21176 
 
21177 
  def write(self, oprot):
21178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21180 
      return
21181 
    oprot.writeStructBegin('getSettlementsByDate_args')
21182 
    if self.settlementDateFrom is not None:
21183 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
21184 
      oprot.writeI64(self.settlementDateFrom)
21185 
      oprot.writeFieldEnd()
21186 
    if self.settlementDateTo is not None:
21187 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
21188 
      oprot.writeI64(self.settlementDateTo)
21189 
      oprot.writeFieldEnd()
21190 
    if self.isRefund is not None:
21191 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
21192 
      oprot.writeBool(self.isRefund)
21193 
      oprot.writeFieldEnd()
21194 
    oprot.writeFieldStop()
21195 
    oprot.writeStructEnd()
21196 
 
21197 
  def validate(self):
21198 
    return
21199 
 
21200 
 
21201 
  def __repr__(self):
21202 
    L = ['%s=%r' % (key, value)
21203 
      for key, value in self.__dict__.iteritems()]
21204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21205 
 
21206 
  def __eq__(self, other):
21207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21208 
 
21209 
  def __ne__(self, other):
21210 
    return not (self == other)
21211 
 
21212 
class getSettlementsByDate_result:
21213 
  """
21214 
  Attributes:
21215 
   - success
21216 
   - ex
21217 
  """
21218 
 
21219 
  thrift_spec = (
21220 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
21221 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21222 
  )
21223 
 
21224 
  def __init__(self, success=None, ex=None,):
21225 
    self.success = success
21226 
    self.ex = ex
21227 
 
21228 
  def read(self, iprot):
21229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21231 
      return
21232 
    iprot.readStructBegin()
21233 
    while True:
21234 
      (fname, ftype, fid) = iprot.readFieldBegin()
21235 
      if ftype == TType.STOP:
21236 
        break
21237 
      if fid == 0:
21238 
        if ftype == TType.LIST:
21239 
          self.success = []
5031 varun.gupt 21240 
          (_etype474, _size471) = iprot.readListBegin()
21241 
          for _i475 in xrange(_size471):
21242 
            _elem476 = PaymentSettlement()
21243 
            _elem476.read(iprot)
21244 
            self.success.append(_elem476)
4715 varun.gupt 21245 
          iprot.readListEnd()
21246 
        else:
21247 
          iprot.skip(ftype)
21248 
      elif fid == 1:
21249 
        if ftype == TType.STRUCT:
21250 
          self.ex = TransactionServiceException()
21251 
          self.ex.read(iprot)
21252 
        else:
21253 
          iprot.skip(ftype)
21254 
      else:
21255 
        iprot.skip(ftype)
21256 
      iprot.readFieldEnd()
21257 
    iprot.readStructEnd()
21258 
 
21259 
  def write(self, oprot):
21260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21262 
      return
21263 
    oprot.writeStructBegin('getSettlementsByDate_result')
21264 
    if self.success is not None:
21265 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21266 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 21267 
      for iter477 in self.success:
21268 
        iter477.write(oprot)
4715 varun.gupt 21269 
      oprot.writeListEnd()
21270 
      oprot.writeFieldEnd()
21271 
    if self.ex is not None:
21272 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21273 
      self.ex.write(oprot)
21274 
      oprot.writeFieldEnd()
21275 
    oprot.writeFieldStop()
21276 
    oprot.writeStructEnd()
21277 
 
21278 
  def validate(self):
21279 
    return
21280 
 
21281 
 
21282 
  def __repr__(self):
21283 
    L = ['%s=%r' % (key, value)
21284 
      for key, value in self.__dict__.iteritems()]
21285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21286 
 
21287 
  def __eq__(self, other):
21288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21289 
 
21290 
  def __ne__(self, other):
21291 
    return not (self == other)
21292 
 
21293 
class getReshippedOrderIds_args:
21294 
  """
21295 
  Attributes:
21296 
   - orderIds
21297 
  """
21298 
 
21299 
  thrift_spec = (
21300 
    None, # 0
21301 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
21302 
  )
21303 
 
21304 
  def __init__(self, orderIds=None,):
21305 
    self.orderIds = orderIds
21306 
 
21307 
  def read(self, iprot):
21308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21310 
      return
21311 
    iprot.readStructBegin()
21312 
    while True:
21313 
      (fname, ftype, fid) = iprot.readFieldBegin()
21314 
      if ftype == TType.STOP:
21315 
        break
21316 
      if fid == 1:
21317 
        if ftype == TType.LIST:
21318 
          self.orderIds = []
5031 varun.gupt 21319 
          (_etype481, _size478) = iprot.readListBegin()
21320 
          for _i482 in xrange(_size478):
21321 
            _elem483 = iprot.readI64();
21322 
            self.orderIds.append(_elem483)
4715 varun.gupt 21323 
          iprot.readListEnd()
21324 
        else:
21325 
          iprot.skip(ftype)
21326 
      else:
21327 
        iprot.skip(ftype)
21328 
      iprot.readFieldEnd()
21329 
    iprot.readStructEnd()
21330 
 
21331 
  def write(self, oprot):
21332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21334 
      return
21335 
    oprot.writeStructBegin('getReshippedOrderIds_args')
21336 
    if self.orderIds is not None:
21337 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
21338 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5031 varun.gupt 21339 
      for iter484 in self.orderIds:
21340 
        oprot.writeI64(iter484)
4715 varun.gupt 21341 
      oprot.writeListEnd()
21342 
      oprot.writeFieldEnd()
21343 
    oprot.writeFieldStop()
21344 
    oprot.writeStructEnd()
21345 
 
21346 
  def validate(self):
21347 
    return
21348 
 
21349 
 
21350 
  def __repr__(self):
21351 
    L = ['%s=%r' % (key, value)
21352 
      for key, value in self.__dict__.iteritems()]
21353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21354 
 
21355 
  def __eq__(self, other):
21356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21357 
 
21358 
  def __ne__(self, other):
21359 
    return not (self == other)
21360 
 
21361 
class getReshippedOrderIds_result:
21362 
  """
21363 
  Attributes:
21364 
   - success
21365 
   - ex
21366 
  """
21367 
 
21368 
  thrift_spec = (
21369 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21370 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21371 
  )
21372 
 
21373 
  def __init__(self, success=None, ex=None,):
21374 
    self.success = success
21375 
    self.ex = ex
21376 
 
21377 
  def read(self, iprot):
21378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21380 
      return
21381 
    iprot.readStructBegin()
21382 
    while True:
21383 
      (fname, ftype, fid) = iprot.readFieldBegin()
21384 
      if ftype == TType.STOP:
21385 
        break
21386 
      if fid == 0:
21387 
        if ftype == TType.LIST:
21388 
          self.success = []
5031 varun.gupt 21389 
          (_etype488, _size485) = iprot.readListBegin()
21390 
          for _i489 in xrange(_size485):
21391 
            _elem490 = iprot.readI64();
21392 
            self.success.append(_elem490)
4715 varun.gupt 21393 
          iprot.readListEnd()
21394 
        else:
21395 
          iprot.skip(ftype)
21396 
      elif fid == 1:
21397 
        if ftype == TType.STRUCT:
21398 
          self.ex = TransactionServiceException()
21399 
          self.ex.read(iprot)
21400 
        else:
21401 
          iprot.skip(ftype)
21402 
      else:
21403 
        iprot.skip(ftype)
21404 
      iprot.readFieldEnd()
21405 
    iprot.readStructEnd()
21406 
 
21407 
  def write(self, oprot):
21408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21410 
      return
21411 
    oprot.writeStructBegin('getReshippedOrderIds_result')
21412 
    if self.success is not None:
21413 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21414 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 21415 
      for iter491 in self.success:
21416 
        oprot.writeI64(iter491)
4715 varun.gupt 21417 
      oprot.writeListEnd()
21418 
      oprot.writeFieldEnd()
21419 
    if self.ex is not None:
21420 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21421 
      self.ex.write(oprot)
21422 
      oprot.writeFieldEnd()
21423 
    oprot.writeFieldStop()
21424 
    oprot.writeStructEnd()
21425 
 
21426 
  def validate(self):
21427 
    return
21428 
 
21429 
 
21430 
  def __repr__(self):
21431 
    L = ['%s=%r' % (key, value)
21432 
      for key, value in self.__dict__.iteritems()]
21433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21434 
 
21435 
  def __eq__(self, other):
21436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21437 
 
21438 
  def __ne__(self, other):
21439 
    return not (self == other)
4757 mandeep.dh 21440 
 
21441 
class updateOrdersAsPORaised_args:
21442 
  """
21443 
  Attributes:
21444 
   - itemIdQuantityMap
21445 
   - purchaseOrderId
21446 
   - warehouseId
21447 
  """
21448 
 
21449 
  thrift_spec = (
21450 
    None, # 0
21451 
    (1, TType.MAP, 'itemIdQuantityMap', (TType.I64,None,TType.I64,None), None, ), # 1
21452 
    (2, TType.I64, 'purchaseOrderId', None, None, ), # 2
21453 
    (3, TType.I64, 'warehouseId', None, None, ), # 3
21454 
  )
21455 
 
21456 
  def __init__(self, itemIdQuantityMap=None, purchaseOrderId=None, warehouseId=None,):
21457 
    self.itemIdQuantityMap = itemIdQuantityMap
21458 
    self.purchaseOrderId = purchaseOrderId
21459 
    self.warehouseId = warehouseId
21460 
 
21461 
  def read(self, iprot):
21462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21464 
      return
21465 
    iprot.readStructBegin()
21466 
    while True:
21467 
      (fname, ftype, fid) = iprot.readFieldBegin()
21468 
      if ftype == TType.STOP:
21469 
        break
21470 
      if fid == 1:
21471 
        if ftype == TType.MAP:
21472 
          self.itemIdQuantityMap = {}
5031 varun.gupt 21473 
          (_ktype493, _vtype494, _size492 ) = iprot.readMapBegin()
21474 
          for _i496 in xrange(_size492):
21475 
            _key497 = iprot.readI64();
21476 
            _val498 = iprot.readI64();
21477 
            self.itemIdQuantityMap[_key497] = _val498
4757 mandeep.dh 21478 
          iprot.readMapEnd()
21479 
        else:
21480 
          iprot.skip(ftype)
21481 
      elif fid == 2:
21482 
        if ftype == TType.I64:
21483 
          self.purchaseOrderId = iprot.readI64();
21484 
        else:
21485 
          iprot.skip(ftype)
21486 
      elif fid == 3:
21487 
        if ftype == TType.I64:
21488 
          self.warehouseId = iprot.readI64();
21489 
        else:
21490 
          iprot.skip(ftype)
21491 
      else:
21492 
        iprot.skip(ftype)
21493 
      iprot.readFieldEnd()
21494 
    iprot.readStructEnd()
21495 
 
21496 
  def write(self, oprot):
21497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21499 
      return
21500 
    oprot.writeStructBegin('updateOrdersAsPORaised_args')
21501 
    if self.itemIdQuantityMap is not None:
21502 
      oprot.writeFieldBegin('itemIdQuantityMap', TType.MAP, 1)
21503 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemIdQuantityMap))
5031 varun.gupt 21504 
      for kiter499,viter500 in self.itemIdQuantityMap.items():
21505 
        oprot.writeI64(kiter499)
21506 
        oprot.writeI64(viter500)
4757 mandeep.dh 21507 
      oprot.writeMapEnd()
21508 
      oprot.writeFieldEnd()
21509 
    if self.purchaseOrderId is not None:
21510 
      oprot.writeFieldBegin('purchaseOrderId', TType.I64, 2)
21511 
      oprot.writeI64(self.purchaseOrderId)
21512 
      oprot.writeFieldEnd()
21513 
    if self.warehouseId is not None:
21514 
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
21515 
      oprot.writeI64(self.warehouseId)
21516 
      oprot.writeFieldEnd()
21517 
    oprot.writeFieldStop()
21518 
    oprot.writeStructEnd()
21519 
 
21520 
  def validate(self):
21521 
    return
21522 
 
21523 
 
21524 
  def __repr__(self):
21525 
    L = ['%s=%r' % (key, value)
21526 
      for key, value in self.__dict__.iteritems()]
21527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21528 
 
21529 
  def __eq__(self, other):
21530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21531 
 
21532 
  def __ne__(self, other):
21533 
    return not (self == other)
21534 
 
21535 
class updateOrdersAsPORaised_result:
21536 
  """
21537 
  Attributes:
21538 
   - ex
21539 
  """
21540 
 
21541 
  thrift_spec = (
21542 
    None, # 0
21543 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21544 
  )
21545 
 
21546 
  def __init__(self, ex=None,):
21547 
    self.ex = ex
21548 
 
21549 
  def read(self, iprot):
21550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21552 
      return
21553 
    iprot.readStructBegin()
21554 
    while True:
21555 
      (fname, ftype, fid) = iprot.readFieldBegin()
21556 
      if ftype == TType.STOP:
21557 
        break
21558 
      if fid == 1:
21559 
        if ftype == TType.STRUCT:
21560 
          self.ex = TransactionServiceException()
21561 
          self.ex.read(iprot)
21562 
        else:
21563 
          iprot.skip(ftype)
21564 
      else:
21565 
        iprot.skip(ftype)
21566 
      iprot.readFieldEnd()
21567 
    iprot.readStructEnd()
21568 
 
21569 
  def write(self, oprot):
21570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21572 
      return
21573 
    oprot.writeStructBegin('updateOrdersAsPORaised_result')
21574 
    if self.ex is not None:
21575 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21576 
      self.ex.write(oprot)
21577 
      oprot.writeFieldEnd()
21578 
    oprot.writeFieldStop()
21579 
    oprot.writeStructEnd()
21580 
 
21581 
  def validate(self):
21582 
    return
21583 
 
21584 
 
21585 
  def __repr__(self):
21586 
    L = ['%s=%r' % (key, value)
21587 
      for key, value in self.__dict__.iteritems()]
21588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21589 
 
21590 
  def __eq__(self, other):
21591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21592 
 
21593 
  def __ne__(self, other):
21594 
    return not (self == other)
4875 varun.gupt 21595 
 
21596 
class getOrdersWhereVendorNotPaid_args:
21597 
  """
21598 
  Attributes:
21599 
   - vendorId
21600 
  """
21601 
 
21602 
  thrift_spec = (
21603 
    None, # 0
21604 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21605 
  )
21606 
 
21607 
  def __init__(self, vendorId=None,):
21608 
    self.vendorId = vendorId
21609 
 
21610 
  def read(self, iprot):
21611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21613 
      return
21614 
    iprot.readStructBegin()
21615 
    while True:
21616 
      (fname, ftype, fid) = iprot.readFieldBegin()
21617 
      if ftype == TType.STOP:
21618 
        break
21619 
      if fid == 1:
21620 
        if ftype == TType.I64:
21621 
          self.vendorId = iprot.readI64();
21622 
        else:
21623 
          iprot.skip(ftype)
21624 
      else:
21625 
        iprot.skip(ftype)
21626 
      iprot.readFieldEnd()
21627 
    iprot.readStructEnd()
21628 
 
21629 
  def write(self, oprot):
21630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21632 
      return
21633 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_args')
21634 
    if self.vendorId is not None:
21635 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21636 
      oprot.writeI64(self.vendorId)
21637 
      oprot.writeFieldEnd()
21638 
    oprot.writeFieldStop()
21639 
    oprot.writeStructEnd()
21640 
 
21641 
  def validate(self):
21642 
    return
21643 
 
21644 
 
21645 
  def __repr__(self):
21646 
    L = ['%s=%r' % (key, value)
21647 
      for key, value in self.__dict__.iteritems()]
21648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21649 
 
21650 
  def __eq__(self, other):
21651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21652 
 
21653 
  def __ne__(self, other):
21654 
    return not (self == other)
21655 
 
21656 
class getOrdersWhereVendorNotPaid_result:
21657 
  """
21658 
  Attributes:
21659 
   - success
21660 
   - ex
21661 
  """
21662 
 
21663 
  thrift_spec = (
21664 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21665 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21666 
  )
21667 
 
21668 
  def __init__(self, success=None, ex=None,):
21669 
    self.success = success
21670 
    self.ex = ex
21671 
 
21672 
  def read(self, iprot):
21673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21675 
      return
21676 
    iprot.readStructBegin()
21677 
    while True:
21678 
      (fname, ftype, fid) = iprot.readFieldBegin()
21679 
      if ftype == TType.STOP:
21680 
        break
21681 
      if fid == 0:
21682 
        if ftype == TType.LIST:
21683 
          self.success = []
5031 varun.gupt 21684 
          (_etype504, _size501) = iprot.readListBegin()
21685 
          for _i505 in xrange(_size501):
21686 
            _elem506 = Order()
21687 
            _elem506.read(iprot)
21688 
            self.success.append(_elem506)
4875 varun.gupt 21689 
          iprot.readListEnd()
21690 
        else:
21691 
          iprot.skip(ftype)
21692 
      elif fid == 1:
21693 
        if ftype == TType.STRUCT:
21694 
          self.ex = TransactionServiceException()
21695 
          self.ex.read(iprot)
21696 
        else:
21697 
          iprot.skip(ftype)
21698 
      else:
21699 
        iprot.skip(ftype)
21700 
      iprot.readFieldEnd()
21701 
    iprot.readStructEnd()
21702 
 
21703 
  def write(self, oprot):
21704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21706 
      return
21707 
    oprot.writeStructBegin('getOrdersWhereVendorNotPaid_result')
21708 
    if self.success is not None:
21709 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21710 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 21711 
      for iter507 in self.success:
21712 
        iter507.write(oprot)
4875 varun.gupt 21713 
      oprot.writeListEnd()
21714 
      oprot.writeFieldEnd()
21715 
    if self.ex is not None:
21716 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21717 
      self.ex.write(oprot)
21718 
      oprot.writeFieldEnd()
21719 
    oprot.writeFieldStop()
21720 
    oprot.writeStructEnd()
21721 
 
21722 
  def validate(self):
21723 
    return
21724 
 
21725 
 
21726 
  def __repr__(self):
21727 
    L = ['%s=%r' % (key, value)
21728 
      for key, value in self.__dict__.iteritems()]
21729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21730 
 
21731 
  def __eq__(self, other):
21732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21733 
 
21734 
  def __ne__(self, other):
21735 
    return not (self == other)
5031 varun.gupt 21736 
 
21737 
class getStatusDistributionOfOrders_args:
21738 
  """
21739 
  Attributes:
21740 
   - startDate
21741 
   - endDate
21742 
  """
21743 
 
21744 
  thrift_spec = (
21745 
    None, # 0
21746 
    (1, TType.I64, 'startDate', None, None, ), # 1
21747 
    (2, TType.I64, 'endDate', None, None, ), # 2
21748 
  )
21749 
 
21750 
  def __init__(self, startDate=None, endDate=None,):
21751 
    self.startDate = startDate
21752 
    self.endDate = endDate
21753 
 
21754 
  def read(self, iprot):
21755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21757 
      return
21758 
    iprot.readStructBegin()
21759 
    while True:
21760 
      (fname, ftype, fid) = iprot.readFieldBegin()
21761 
      if ftype == TType.STOP:
21762 
        break
21763 
      if fid == 1:
21764 
        if ftype == TType.I64:
21765 
          self.startDate = iprot.readI64();
21766 
        else:
21767 
          iprot.skip(ftype)
21768 
      elif fid == 2:
21769 
        if ftype == TType.I64:
21770 
          self.endDate = iprot.readI64();
21771 
        else:
21772 
          iprot.skip(ftype)
21773 
      else:
21774 
        iprot.skip(ftype)
21775 
      iprot.readFieldEnd()
21776 
    iprot.readStructEnd()
21777 
 
21778 
  def write(self, oprot):
21779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21781 
      return
21782 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
21783 
    if self.startDate is not None:
21784 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
21785 
      oprot.writeI64(self.startDate)
21786 
      oprot.writeFieldEnd()
21787 
    if self.endDate is not None:
21788 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
21789 
      oprot.writeI64(self.endDate)
21790 
      oprot.writeFieldEnd()
21791 
    oprot.writeFieldStop()
21792 
    oprot.writeStructEnd()
21793 
 
21794 
  def validate(self):
21795 
    return
21796 
 
21797 
 
21798 
  def __repr__(self):
21799 
    L = ['%s=%r' % (key, value)
21800 
      for key, value in self.__dict__.iteritems()]
21801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21802 
 
21803 
  def __eq__(self, other):
21804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21805 
 
21806 
  def __ne__(self, other):
21807 
    return not (self == other)
21808 
 
21809 
class getStatusDistributionOfOrders_result:
21810 
  """
21811 
  Attributes:
21812 
   - success
21813 
   - ex
21814 
  """
21815 
 
21816 
  thrift_spec = (
21817 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
21818 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21819 
  )
21820 
 
21821 
  def __init__(self, success=None, ex=None,):
21822 
    self.success = success
21823 
    self.ex = ex
21824 
 
21825 
  def read(self, iprot):
21826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21828 
      return
21829 
    iprot.readStructBegin()
21830 
    while True:
21831 
      (fname, ftype, fid) = iprot.readFieldBegin()
21832 
      if ftype == TType.STOP:
21833 
        break
21834 
      if fid == 0:
21835 
        if ftype == TType.MAP:
21836 
          self.success = {}
21837 
          (_ktype509, _vtype510, _size508 ) = iprot.readMapBegin()
21838 
          for _i512 in xrange(_size508):
21839 
            _key513 = iprot.readI64();
21840 
            _val514 = iprot.readI64();
21841 
            self.success[_key513] = _val514
21842 
          iprot.readMapEnd()
21843 
        else:
21844 
          iprot.skip(ftype)
21845 
      elif fid == 1:
21846 
        if ftype == TType.STRUCT:
21847 
          self.ex = TransactionServiceException()
21848 
          self.ex.read(iprot)
21849 
        else:
21850 
          iprot.skip(ftype)
21851 
      else:
21852 
        iprot.skip(ftype)
21853 
      iprot.readFieldEnd()
21854 
    iprot.readStructEnd()
21855 
 
21856 
  def write(self, oprot):
21857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21859 
      return
21860 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
21861 
    if self.success is not None:
21862 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21863 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
21864 
      for kiter515,viter516 in self.success.items():
21865 
        oprot.writeI64(kiter515)
21866 
        oprot.writeI64(viter516)
21867 
      oprot.writeMapEnd()
21868 
      oprot.writeFieldEnd()
21869 
    if self.ex is not None:
21870 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21871 
      self.ex.write(oprot)
21872 
      oprot.writeFieldEnd()
21873 
    oprot.writeFieldStop()
21874 
    oprot.writeStructEnd()
21875 
 
21876 
  def validate(self):
21877 
    return
21878 
 
21879 
 
21880 
  def __repr__(self):
21881 
    L = ['%s=%r' % (key, value)
21882 
      for key, value in self.__dict__.iteritems()]
21883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21884 
 
21885 
  def __eq__(self, other):
21886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21887 
 
21888 
  def __ne__(self, other):
21889 
    return not (self == other)
5067 varun.gupt 21890 
 
21891 
class getOrderIdsForStatus_args:
21892 
  """
21893 
  Attributes:
21894 
   - status
21895 
   - startDatetime
21896 
   - endDatetime
21897 
  """
21898 
 
21899 
  thrift_spec = (
21900 
    None, # 0
21901 
    (1, TType.I64, 'status', None, None, ), # 1
21902 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
21903 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
21904 
  )
21905 
 
21906 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
21907 
    self.status = status
21908 
    self.startDatetime = startDatetime
21909 
    self.endDatetime = endDatetime
21910 
 
21911 
  def read(self, iprot):
21912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21914 
      return
21915 
    iprot.readStructBegin()
21916 
    while True:
21917 
      (fname, ftype, fid) = iprot.readFieldBegin()
21918 
      if ftype == TType.STOP:
21919 
        break
21920 
      if fid == 1:
21921 
        if ftype == TType.I64:
21922 
          self.status = iprot.readI64();
21923 
        else:
21924 
          iprot.skip(ftype)
21925 
      elif fid == 2:
21926 
        if ftype == TType.I64:
21927 
          self.startDatetime = iprot.readI64();
21928 
        else:
21929 
          iprot.skip(ftype)
21930 
      elif fid == 3:
21931 
        if ftype == TType.I64:
21932 
          self.endDatetime = iprot.readI64();
21933 
        else:
21934 
          iprot.skip(ftype)
21935 
      else:
21936 
        iprot.skip(ftype)
21937 
      iprot.readFieldEnd()
21938 
    iprot.readStructEnd()
21939 
 
21940 
  def write(self, oprot):
21941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21943 
      return
21944 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
21945 
    if self.status is not None:
21946 
      oprot.writeFieldBegin('status', TType.I64, 1)
21947 
      oprot.writeI64(self.status)
21948 
      oprot.writeFieldEnd()
21949 
    if self.startDatetime is not None:
21950 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
21951 
      oprot.writeI64(self.startDatetime)
21952 
      oprot.writeFieldEnd()
21953 
    if self.endDatetime is not None:
21954 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
21955 
      oprot.writeI64(self.endDatetime)
21956 
      oprot.writeFieldEnd()
21957 
    oprot.writeFieldStop()
21958 
    oprot.writeStructEnd()
21959 
 
21960 
  def validate(self):
21961 
    return
21962 
 
21963 
 
21964 
  def __repr__(self):
21965 
    L = ['%s=%r' % (key, value)
21966 
      for key, value in self.__dict__.iteritems()]
21967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21968 
 
21969 
  def __eq__(self, other):
21970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21971 
 
21972 
  def __ne__(self, other):
21973 
    return not (self == other)
21974 
 
21975 
class getOrderIdsForStatus_result:
21976 
  """
21977 
  Attributes:
21978 
   - success
21979 
   - ex
21980 
  """
21981 
 
21982 
  thrift_spec = (
21983 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21984 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21985 
  )
21986 
 
21987 
  def __init__(self, success=None, ex=None,):
21988 
    self.success = success
21989 
    self.ex = ex
21990 
 
21991 
  def read(self, iprot):
21992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21994 
      return
21995 
    iprot.readStructBegin()
21996 
    while True:
21997 
      (fname, ftype, fid) = iprot.readFieldBegin()
21998 
      if ftype == TType.STOP:
21999 
        break
22000 
      if fid == 0:
22001 
        if ftype == TType.LIST:
22002 
          self.success = []
22003 
          (_etype520, _size517) = iprot.readListBegin()
22004 
          for _i521 in xrange(_size517):
22005 
            _elem522 = iprot.readI64();
22006 
            self.success.append(_elem522)
22007 
          iprot.readListEnd()
22008 
        else:
22009 
          iprot.skip(ftype)
22010 
      elif fid == 1:
22011 
        if ftype == TType.STRUCT:
22012 
          self.ex = TransactionServiceException()
22013 
          self.ex.read(iprot)
22014 
        else:
22015 
          iprot.skip(ftype)
22016 
      else:
22017 
        iprot.skip(ftype)
22018 
      iprot.readFieldEnd()
22019 
    iprot.readStructEnd()
22020 
 
22021 
  def write(self, oprot):
22022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22024 
      return
22025 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
22026 
    if self.success is not None:
22027 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22028 
      oprot.writeListBegin(TType.I64, len(self.success))
22029 
      for iter523 in self.success:
22030 
        oprot.writeI64(iter523)
22031 
      oprot.writeListEnd()
22032 
      oprot.writeFieldEnd()
22033 
    if self.ex is not None:
22034 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22035 
      self.ex.write(oprot)
22036 
      oprot.writeFieldEnd()
22037 
    oprot.writeFieldStop()
22038 
    oprot.writeStructEnd()
22039 
 
22040 
  def validate(self):
22041 
    return
22042 
 
22043 
 
22044 
  def __repr__(self):
22045 
    L = ['%s=%r' % (key, value)
22046 
      for key, value in self.__dict__.iteritems()]
22047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22048 
 
22049 
  def __eq__(self, other):
22050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22051 
 
22052 
  def __ne__(self, other):
22053 
    return not (self == other)
5099 varun.gupt 22054 
 
22055 
class updateOrderAsPaidToVendor_args:
22056 
  """
22057 
  Attributes:
22058 
   - orderId
22059 
  """
22060 
 
22061 
  thrift_spec = (
22062 
    None, # 0
22063 
    (1, TType.I64, 'orderId', None, None, ), # 1
22064 
  )
22065 
 
22066 
  def __init__(self, orderId=None,):
22067 
    self.orderId = orderId
22068 
 
22069 
  def read(self, iprot):
22070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22072 
      return
22073 
    iprot.readStructBegin()
22074 
    while True:
22075 
      (fname, ftype, fid) = iprot.readFieldBegin()
22076 
      if ftype == TType.STOP:
22077 
        break
22078 
      if fid == 1:
22079 
        if ftype == TType.I64:
22080 
          self.orderId = iprot.readI64();
22081 
        else:
22082 
          iprot.skip(ftype)
22083 
      else:
22084 
        iprot.skip(ftype)
22085 
      iprot.readFieldEnd()
22086 
    iprot.readStructEnd()
22087 
 
22088 
  def write(self, oprot):
22089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22091 
      return
22092 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
22093 
    if self.orderId is not None:
22094 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22095 
      oprot.writeI64(self.orderId)
22096 
      oprot.writeFieldEnd()
22097 
    oprot.writeFieldStop()
22098 
    oprot.writeStructEnd()
22099 
 
22100 
  def validate(self):
22101 
    return
22102 
 
22103 
 
22104 
  def __repr__(self):
22105 
    L = ['%s=%r' % (key, value)
22106 
      for key, value in self.__dict__.iteritems()]
22107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22108 
 
22109 
  def __eq__(self, other):
22110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22111 
 
22112 
  def __ne__(self, other):
22113 
    return not (self == other)
22114 
 
22115 
class updateOrderAsPaidToVendor_result:
22116 
  """
22117 
  Attributes:
22118 
   - ex
22119 
  """
22120 
 
22121 
  thrift_spec = (
22122 
    None, # 0
22123 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22124 
  )
22125 
 
22126 
  def __init__(self, ex=None,):
22127 
    self.ex = ex
22128 
 
22129 
  def read(self, iprot):
22130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22132 
      return
22133 
    iprot.readStructBegin()
22134 
    while True:
22135 
      (fname, ftype, fid) = iprot.readFieldBegin()
22136 
      if ftype == TType.STOP:
22137 
        break
22138 
      if fid == 1:
22139 
        if ftype == TType.STRUCT:
22140 
          self.ex = TransactionServiceException()
22141 
          self.ex.read(iprot)
22142 
        else:
22143 
          iprot.skip(ftype)
22144 
      else:
22145 
        iprot.skip(ftype)
22146 
      iprot.readFieldEnd()
22147 
    iprot.readStructEnd()
22148 
 
22149 
  def write(self, oprot):
22150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22152 
      return
22153 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
22154 
    if self.ex is not None:
22155 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22156 
      self.ex.write(oprot)
22157 
      oprot.writeFieldEnd()
22158 
    oprot.writeFieldStop()
22159 
    oprot.writeStructEnd()
22160 
 
22161 
  def validate(self):
22162 
    return
22163 
 
22164 
 
22165 
  def __repr__(self):
22166 
    L = ['%s=%r' % (key, value)
22167 
      for key, value in self.__dict__.iteritems()]
22168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22169 
 
22170 
  def __eq__(self, other):
22171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22172 
 
22173 
  def __ne__(self, other):
22174 
    return not (self == other)
5208 varun.gupt 22175 
 
22176 
class getRefundedOrdersMarkedPaid_args:
22177 
 
22178 
  thrift_spec = (
22179 
  )
22180 
 
22181 
  def read(self, iprot):
22182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22184 
      return
22185 
    iprot.readStructBegin()
22186 
    while True:
22187 
      (fname, ftype, fid) = iprot.readFieldBegin()
22188 
      if ftype == TType.STOP:
22189 
        break
22190 
      else:
22191 
        iprot.skip(ftype)
22192 
      iprot.readFieldEnd()
22193 
    iprot.readStructEnd()
22194 
 
22195 
  def write(self, oprot):
22196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22198 
      return
22199 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
22200 
    oprot.writeFieldStop()
22201 
    oprot.writeStructEnd()
22202 
 
22203 
  def validate(self):
22204 
    return
22205 
 
22206 
 
22207 
  def __repr__(self):
22208 
    L = ['%s=%r' % (key, value)
22209 
      for key, value in self.__dict__.iteritems()]
22210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22211 
 
22212 
  def __eq__(self, other):
22213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22214 
 
22215 
  def __ne__(self, other):
22216 
    return not (self == other)
22217 
 
22218 
class getRefundedOrdersMarkedPaid_result:
22219 
  """
22220 
  Attributes:
22221 
   - success
22222 
   - ex
22223 
  """
22224 
 
22225 
  thrift_spec = (
22226 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22227 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22228 
  )
22229 
 
22230 
  def __init__(self, success=None, ex=None,):
22231 
    self.success = success
22232 
    self.ex = ex
22233 
 
22234 
  def read(self, iprot):
22235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22237 
      return
22238 
    iprot.readStructBegin()
22239 
    while True:
22240 
      (fname, ftype, fid) = iprot.readFieldBegin()
22241 
      if ftype == TType.STOP:
22242 
        break
22243 
      if fid == 0:
22244 
        if ftype == TType.LIST:
22245 
          self.success = []
22246 
          (_etype527, _size524) = iprot.readListBegin()
22247 
          for _i528 in xrange(_size524):
22248 
            _elem529 = Order()
22249 
            _elem529.read(iprot)
22250 
            self.success.append(_elem529)
22251 
          iprot.readListEnd()
22252 
        else:
22253 
          iprot.skip(ftype)
22254 
      elif fid == 1:
22255 
        if ftype == TType.STRUCT:
22256 
          self.ex = TransactionServiceException()
22257 
          self.ex.read(iprot)
22258 
        else:
22259 
          iprot.skip(ftype)
22260 
      else:
22261 
        iprot.skip(ftype)
22262 
      iprot.readFieldEnd()
22263 
    iprot.readStructEnd()
22264 
 
22265 
  def write(self, oprot):
22266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22268 
      return
22269 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
22270 
    if self.success is not None:
22271 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22272 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
22273 
      for iter530 in self.success:
22274 
        iter530.write(oprot)
22275 
      oprot.writeListEnd()
22276 
      oprot.writeFieldEnd()
22277 
    if self.ex is not None:
22278 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22279 
      self.ex.write(oprot)
22280 
      oprot.writeFieldEnd()
22281 
    oprot.writeFieldStop()
22282 
    oprot.writeStructEnd()
22283 
 
22284 
  def validate(self):
22285 
    return
22286 
 
22287 
 
22288 
  def __repr__(self):
22289 
    L = ['%s=%r' % (key, value)
22290 
      for key, value in self.__dict__.iteritems()]
22291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22292 
 
22293 
  def __eq__(self, other):
22294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22295 
 
22296 
  def __ne__(self, other):
22297 
    return not (self == other)